From 8d716415c5de08be0d4f9c1b63ac674436a48929 Mon Sep 17 00:00:00 2001 From: Dan Draper Date: Sat, 10 Oct 2026 10:15:02 +1100 Subject: [PATCH 1/3] refactor(eql): write the SQL source with schema and version placeholders ADR-0002 separates the two producers of EQL payloads by Postgres type: cipherstash-client's terms stay in eql_v3, Stack Encrypt's move to eql_v4, and both come from one SQL source. This is the first step of #1141: the source stops naming its schemas and payload version literally. The hand-written SQL under src/v3, the version template, the search_path pin script and the uninstaller now write {{prefix}} where they wrote eql_v3, and {{eql_version}} where domain CHECKs compared VALUE->>'v' to '3'. eql-codegen emits the same placeholders: its schema, typname-prefix and version constants are placeholder strings, and its unit tests render output as v3 before asserting. The Rust bindings keep the literal eql_v3_ prefix because they describe v3 payloads. A new `eql-codegen render <3|4> ...` substitutes them. It refuses an unknown or unterminated placeholder and any literal eql_v3 or eql_v4, since a literal name would render the same for both versions and let the v4 bundle reach into v3. build.sh renders the ordered surface into build/render/eql_v3/ and runs the symbol-order and installer-completeness gates on the rendered files. The docs tooling reads rendered SQL too. The committed generated surface is regenerated in the next commit, so codegen:parity fails at this one alone. Refs #1141 --- packages/eql/.gitattributes | 3 + packages/eql/.gitignore | 4 + packages/eql/AGENTS.md | 15 + .../eql/crates/eql-codegen/src/bindings.rs | 13 +- packages/eql/crates/eql-codegen/src/consts.rs | 23 +- .../eql/crates/eql-codegen/src/context.rs | 13 +- .../eql/crates/eql-codegen/src/generate.rs | 65 +++- packages/eql/crates/eql-codegen/src/lib.rs | 1 + packages/eql/crates/eql-codegen/src/main.rs | 28 ++ packages/eql/crates/eql-codegen/src/render.rs | 290 ++++++++++++++++ .../eql-codegen/templates/ore_fallback.sql.j2 | 2 +- .../eql-codegen/templates/query_types.sql.j2 | 2 +- .../crates/eql-codegen/templates/types.sql.j2 | 2 +- packages/eql/crates/eql-codegen/tests/cli.rs | 2 +- .../adding-a-scalar-encrypted-domain-type.md | 8 +- packages/eql/mise.toml | 4 +- packages/eql/src/v3/aggregates.sql | 44 +-- packages/eql/src/v3/common.sql | 8 +- packages/eql/src/v3/crypto.sql | 6 +- packages/eql/src/v3/json/aggregates.sql | 76 ++--- packages/eql/src/v3/json/blockers.sql | 316 +++++++++--------- packages/eql/src/v3/json/functions.sql | 180 +++++----- packages/eql/src/v3/json/operators.sql | 214 ++++++------ packages/eql/src/v3/json/types.sql | 88 ++--- packages/eql/src/v3/lint/lints.sql | 48 +-- packages/eql/src/v3/scalars/functions.sql | 14 +- packages/eql/src/v3/schema.sql | 46 +-- .../eql/src/v3/sem/bloom_filter/functions.sql | 20 +- .../eql/src/v3/sem/bloom_filter/types.sql | 8 +- .../eql/src/v3/sem/hmac_256/functions.sql | 16 +- packages/eql/src/v3/sem/hmac_256/types.sql | 6 +- .../eql/src/v3/sem/ope_cllw/functions.sql | 16 +- packages/eql/src/v3/sem/ope_cllw/types.sql | 12 +- .../src/v3/sem/ore_block_256/functions.sql | 54 +-- .../v3/sem/ore_block_256/operator_class.sql | 22 +- .../src/v3/sem/ore_block_256/operators.sql | 102 +++--- .../eql/src/v3/sem/ore_block_256/types.sql | 10 +- packages/eql/src/v3/version.template | 14 +- packages/eql/tasks/build.sh | 57 +++- packages/eql/tasks/docs/doxygen-filter.sh | 6 +- .../eql/tasks/docs/validate/documented-sql.sh | 5 +- packages/eql/tasks/pin_search_path_v3.sql | 16 +- packages/eql/tasks/test/docs_v3_grep.sh | 2 +- .../tasks/test/verify_installer_complete.sh | 9 +- .../eql/tasks/test/verify_symbol_order_v3.sh | 2 +- packages/eql/tasks/uninstall-v3.sql | 14 +- 46 files changed, 1180 insertions(+), 726 deletions(-) create mode 100644 packages/eql/crates/eql-codegen/src/render.rs diff --git a/packages/eql/.gitattributes b/packages/eql/.gitattributes index cb53a3516..dc8060fd3 100644 --- a/packages/eql/.gitattributes +++ b/packages/eql/.gitattributes @@ -8,6 +8,8 @@ # and drift-gated by `mise run codegen:parity`. (The hand-written # src/v3/scalars/functions.sql and *_extensions.sql are NOT generated and # are deliberately left unmarked.) +# - src/v3/scalars/ore_fallback.sql : the one generated file directly under +# src/v3/scalars, outside the per-type directories the globs above match. # - tests/sqlx/snapshots/*_expanded.rs : `cargo expand` snapshots of the # scalar matrix macros (the start_line/end_line churn is location drift). # - tests/sqlx/snapshots/matrix_tests*.txt : matrix-coverage inventory pinned @@ -19,6 +21,7 @@ src/v3/scalars/*/*_types.sql linguist-generated src/v3/scalars/*/*_functions.sql linguist-generated src/v3/scalars/*/*_operators.sql linguist-generated src/v3/scalars/*/*_aggregates.sql linguist-generated +src/v3/scalars/ore_fallback.sql linguist-generated tests/sqlx/snapshots/*_expanded.rs linguist-generated tests/sqlx/snapshots/matrix_tests*.txt linguist-generated diff --git a/packages/eql/.gitignore b/packages/eql/.gitignore index d7ce9d61a..46bf60b2e 100644 --- a/packages/eql/.gitignore +++ b/packages/eql/.gitignore @@ -260,3 +260,7 @@ nextest.tar.zst docs/decisions/2026-06-10-eql-v3-json-type-kind.md docs/handoff/2026-06-10-v3-jsonb-fixture-alignment.md .claude/ + +# Rendered SQL per EQL version, written by tasks/build.sh from the placeholder +# source (ADR-0002). +build/ diff --git a/packages/eql/AGENTS.md b/packages/eql/AGENTS.md index b6e5e1929..28b56e997 100644 --- a/packages/eql/AGENTS.md +++ b/packages/eql/AGENTS.md @@ -42,6 +42,21 @@ This project uses `mise` for task management. Common commands: - `cipherstash-encrypt.sql` - The sole installer: the self-contained `eql_v3` surface, globbed from `src/v3` only (no `eql_v2`; installable into a DB with no `eql_v2` present) - `cipherstash-encrypt-uninstall.sql` - Matching uninstaller +#### Schema and version placeholders + +The SQL source never names its schemas or its payload version literally. It writes two placeholders, and the build renders the one source once per EQL version (ADR-0002, `docs/adr/0002-*` at the repo root): + +| placeholder | rendered for `eql_v3` | rendered for `eql_v4` | +|---|---|---| +| `{{prefix}}` | `eql_v3` | `eql_v4` | +| `{{eql_version}}` | `3` | `4` | + +`{{prefix}}` is the schema and the start of every other name: `{{prefix}}.eq_term`, `{{prefix}}_internal.hmac_256`, `public.{{prefix}}_text_eq`. `{{eql_version}}` appears in every domain CHECK: `VALUE->>'v' = '{{eql_version}}'`. This covers every file under `src/v3/` (hand-written and generated), `src/v3/version.template`, `tasks/pin_search_path_v3.sql` and `tasks/uninstall-v3.sql`. The generator emits the placeholders too: `SCHEMA`, `INTERNAL_SCHEMA`, `PUBLIC_TYPNAME_PREFIX` and `EQL_VERSION` in `crates/eql-codegen/src/consts.rs` are placeholder strings. The Rust bindings are the exception. They describe v3 payloads and keep `eql_domains::PUBLIC_TYPNAME_PREFIX`, the literal `eql_v3_`. + +`tasks/build.sh` renders the ordered source into `build/render/eql_v3/` (gitignored, same relative paths) with `eql-codegen render`, runs the symbol-order and installer-completeness gates on the rendered files, and assembles `release/` from them. The renderer refuses three things: an unknown placeholder, an unterminated `{{`, and a **literal `eql_v3` or `eql_v4`** anywhere in the source, comments included. A literal name renders identically for both versions, so the v4 bundle would reach into v3. Write the placeholder in prose too. + +Anything that needs the source as real SQL reads the rendered tree, not `src/`: `docs:validate:documented-sql` runs psql over `build/render/eql_v3/src`, and the Doxygen input filter (`tasks/docs/doxygen-filter.sh`) renders `eql_v3` names on the fly. A new tool that parses `src/v3` must do one or the other. + There are no longer separate Main / Supabase / Protect / v3-only build variants. The combined `eql_v2` build that previously produced multiple artefacts has been removed; the v3 surface now ships as one self-contained installer under the canonical `cipherstash-encrypt.sql` name (`eql-codegen order` walks `src/v3` only). Because the surface owns no `eql_v2` dependency, it is already Supabase / managed-Postgres compatible (functional indexes over extractors, no superuser-only operator classes) without a dedicated subset build. Self-containment — no `-- REQUIRE:` edge pointing outside `src/v3`, no `eql_v2.` anywhere in the surface — is enforced at build time by `surface_order`'s `OutsideSurface` error (`crates/eql-codegen/src/ordering.rs`) and CI-gated by `mise run test:self_contained_v3`. ## Project Architecture diff --git a/packages/eql/crates/eql-codegen/src/bindings.rs b/packages/eql/crates/eql-codegen/src/bindings.rs index d785beccf..2fe4be39a 100644 --- a/packages/eql/crates/eql-codegen/src/bindings.rs +++ b/packages/eql/crates/eql-codegen/src/bindings.rs @@ -91,6 +91,13 @@ fn capability_label(domain_name: &str) -> &'static str { /// `Term::term_json_keys`) — so it stays deterministic and cannot drift from the /// payload shape. No free-form prose and no field docs: per-field semantics live /// on the shared term newtypes (`terms.rs`) and per-family caveats in `mod.rs`. +/// The schema-qualified `eql_v3` domain a payload struct binds, e.g. +/// `public.eql_v3_integer_eq`. The bindings describe v3 payloads only, so they +/// name it literally, where the SQL surface writes the `{{prefix}}` placeholder. +fn v3_domain_name(full: &str) -> String { + format!("public.{}{full}", eql_domains::PUBLIC_TYPNAME_PREFIX) +} + fn struct_doc_lines(full: &str, domain: &Domain) -> [String; 3] { // Leading space matches the `///` doc-comment convention (`#[doc = " …"]`): // rustfmt renders it as `/// …` and ts-rs as ` * …`. Without it the emitted @@ -98,7 +105,7 @@ fn struct_doc_lines(full: &str, domain: &Domain) -> [String; 3] { // single leading space, so JSON Schema `description` is unaffected. let summary = format!( " `{}` — {}.", - crate::context::domain_name(full), + v3_domain_name(full), capability_label(domain.name) ); @@ -162,7 +169,7 @@ fn reference_docs(family: &DomainFamily) -> TokenStream { fn render_struct(family: &DomainFamily, domain: &Domain) -> TokenStream { let full = domain.full_name(family.name); let ident = format_ident!("{}", domain.struct_ident(family.name)); - let sql_domain = crate::context::domain_name(&full); + let sql_domain = v3_domain_name(&full); let [doc_summary, doc_blank, doc_detail] = struct_doc_lines(&full, domain); let reference = reference_docs(family); let (encryption, version, context) = encryption_attrs(family, domain, false); @@ -604,7 +611,7 @@ pub fn render_payload_rs() -> String { let module = format_ident!("{}", f.name); let strukt = format_ident!("{}", d.rust_struct_name(f.name)); let full = d.full_name(f.name); - let doc = format!(" The `{}` payload.", crate::context::domain_name(&full)); + let doc = format!(" The `{}` payload.", v3_domain_name(&full)); variants.extend(quote! { #[doc = #doc] #strukt(super::#module::#strukt), diff --git a/packages/eql/crates/eql-codegen/src/consts.rs b/packages/eql/crates/eql-codegen/src/consts.rs index 3422195f5..dbbae25a1 100644 --- a/packages/eql/crates/eql-codegen/src/consts.rs +++ b/packages/eql/crates/eql-codegen/src/consts.rs @@ -14,7 +14,11 @@ pub(crate) const AUTO_GENERATED_MARKER: &str = "-- AUTOMATICALLY GENERATED FILE. pub(crate) const RUST_GENERATED_MARKER: &str = "// @generated by eql-codegen from the eql-domains catalog — do not edit"; -/// The public `eql_v3` API surface: query operators, index extractors, +/// The generated SQL names its schemas and payload version by placeholder, +/// never literally: [`crate::render`] writes the one source out as `eql_v3` +/// (version 3) and `eql_v4` (version 4). See ADR-0002. +/// +/// The public API schema (`eql_v3` once rendered): query operators, index extractors, /// aggregates, AND the operator-backing comparison **wrappers** /// (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`). The wrappers /// are public because they are the function-form equivalent of every supported @@ -22,7 +26,7 @@ pub(crate) const RUST_GENERATED_MARKER: &str = /// calls functions, not operators). User-column encrypted domains live in /// `public`; only index-term TYPES and never-invoked plumbing live in /// `INTERNAL_SCHEMA`. -pub(crate) const SCHEMA: &str = "eql_v3"; +pub(crate) const SCHEMA: &str = "{{prefix}}"; /// The schema housing INTERNAL eql_v3 objects only: the SEM index-term types /// (`hmac_256`, `bloom_filter`, `ore_block_256(_term)`, `ope_cllw`) and their @@ -33,7 +37,16 @@ pub(crate) const SCHEMA: &str = "eql_v3"; /// picker. NOTE: the operator-backing comparison *wrappers* are NOT here — /// they are public in `SCHEMA` (see above) so every operator has a callable /// function equivalent. -pub(crate) const INTERNAL_SCHEMA: &str = "eql_v3_internal"; +pub(crate) const INTERNAL_SCHEMA: &str = "{{prefix}}_internal"; + +/// The bare typname prefix of every public-schema encrypted domain, e.g. the +/// `{{prefix}}_` of `public.{{prefix}}_integer_eq`. The SQL counterpart of +/// [`eql_domains::PUBLIC_TYPNAME_PREFIX`], which stays the literal `eql_v3_` +/// for the Rust bindings: those describe v3 payloads only. +pub(crate) const PUBLIC_TYPNAME_PREFIX: &str = "{{prefix}}_"; + +/// The payload version every domain CHECK compares `VALUE->>'v'` against. +pub(crate) const EQL_VERSION: &str = "{{eql_version}}"; /// Always-present payload keys checked for presence in every domain CHECK. /// Term-specific keys are appended after these by `context::domain_block`. @@ -69,8 +82,8 @@ mod tests { // `list-schemas` subcommand) so a hand-edit to one side without the // other fails CI. Pinning the values here catches a Rust-side rename // before the SQL is even consulted. - assert_eq!(SCHEMA, "eql_v3"); - assert_eq!(INTERNAL_SCHEMA, "eql_v3_internal"); + assert_eq!(SCHEMA, "{{prefix}}"); + assert_eq!(INTERNAL_SCHEMA, "{{prefix}}_internal"); // `owned_schemas()` (lib.rs) is the public accessor the binary prints; // it must derive from these consts, public first. assert_eq!(crate::owned_schemas(), [SCHEMA, INTERNAL_SCHEMA]); diff --git a/packages/eql/crates/eql-codegen/src/context.rs b/packages/eql/crates/eql-codegen/src/context.rs index 066bdb189..cc94907a2 100644 --- a/packages/eql/crates/eql-codegen/src/context.rs +++ b/packages/eql/crates/eql-codegen/src/context.rs @@ -61,6 +61,7 @@ pub fn environment() -> minijinja::Environment<'static> { .expect("ore_fallback.sql template"); env.add_global("schema", SCHEMA); env.add_global("internal_schema", INTERNAL_SCHEMA); + env.add_global("eql_version", EQL_VERSION); env } @@ -390,15 +391,15 @@ pub struct OreFallbackEntry { } /// The bare pg_type typname of a public-schema encrypted domain: the catalog -/// name carrying the [`eql_domains::PUBLIC_TYPNAME_PREFIX`] version prefix, -/// e.g. `eql_v3_integer_eq`. The prefix keeps EQL domains from +/// name carrying the [`PUBLIC_TYPNAME_PREFIX`] version prefix, +/// e.g. `{{prefix}}_integer_eq` (`eql_v3_integer_eq` once rendered). The prefix keeps EQL domains from /// shadowing PostgreSQL built-in type names (`integer`, `text`, `json`, …) /// and gives each EQL version a distinct column-type namespace so multiple /// versions can coexist in one database. Catalog names stay bare — the prefix /// is applied only at SQL-name construction (file names, REQUIRE paths, /// struct idents, and test names all keep the bare name). pub fn public_typname(name: &str) -> String { - format!("{}{name}", eql_domains::PUBLIC_TYPNAME_PREFIX) + format!("{PUBLIC_TYPNAME_PREFIX}{name}") } /// The schema-qualified SQL domain type name, e.g. `public.eql_v3_integer_eq`. @@ -463,13 +464,13 @@ mod tests { #[test] fn domain_name_qualifies_user_domains_with_public_schema() { - assert_eq!(domain_name("integer_eq"), "public.eql_v3_integer_eq"); + assert_eq!(domain_name("integer_eq"), "public.{{prefix}}_integer_eq"); } #[test] fn public_typname_carries_version_prefix() { - assert_eq!(public_typname("integer"), "eql_v3_integer"); - assert_eq!(public_typname("text_match"), "eql_v3_text_match"); + assert_eq!(public_typname("integer"), "{{prefix}}_integer"); + assert_eq!(public_typname("text_match"), "{{prefix}}_text_match"); } #[test] diff --git a/packages/eql/crates/eql-codegen/src/generate.rs b/packages/eql/crates/eql-codegen/src/generate.rs index 2e5ac00ae..d6c70836e 100644 --- a/packages/eql/crates/eql-codegen/src/generate.rs +++ b/packages/eql/crates/eql-codegen/src/generate.rs @@ -1150,6 +1150,65 @@ mod tests { .expect("domain name") } + // The renderers emit placeholder SQL. These shadow them, rendering their + // output as eql_v3, so the assertions below read as installed SQL and every + // rendered file is also checked to be free of literal names and unknown + // placeholders. + fn v3(sql: String) -> String { + crate::render::render_str(&sql, crate::render::EqlVersion::V3).expect("renders as eql_v3") + } + + fn render_types_file(spec: &DomainFamily) -> String { + v3(super::render_types_file(spec)) + } + + fn render_functions_file(family_name: &str, domain: &Domain) -> String { + v3(super::render_functions_file(family_name, domain)) + } + + fn render_operators_file(family_name: &str, domain: &Domain) -> String { + v3(super::render_operators_file(family_name, domain)) + } + + fn render_aggregates_file(family_name: &str, domain: &Domain) -> Option { + super::render_aggregates_file(family_name, domain).map(v3) + } + + fn render_ore_fallback_file() -> String { + v3(super::render_ore_fallback_file()) + } + + fn render_json_entry_cross_functions( + spec: &DomainFamily, + domains: &[&Domain], + blocked_domains: &[&Domain], + ) -> String { + v3(super::render_json_entry_cross_functions( + spec, + domains, + blocked_domains, + )) + } + + fn render_json_entry_cross_operators( + spec: &DomainFamily, + domains: &[&Domain], + blocked_domains: &[&Domain], + ) -> String { + v3(super::render_json_entry_cross_operators( + spec, + domains, + blocked_domains, + )) + } + + fn render_type(spec: &DomainFamily, out_dir: &Path) -> Vec<(PathBuf, String)> { + super::render_type(spec, out_dir) + .into_iter() + .map(|(p, sql)| (p, v3(sql))) + .collect() + } + use std::fs; #[test] @@ -1873,8 +1932,8 @@ mod tests { shape: Shape::Scalar, }, ); - assert_eq!(block.typname, "eql_v3_integer_q"); // no quote present → unchanged - // keys are sql_str-escaped key tokens; none should carry a bare unescaped quote. + assert_eq!(block.typname, "{{prefix}}_integer_q"); // no quote present → unchanged + // keys are sql_str-escaped key tokens; none should carry a bare unescaped quote. assert!(block.keys.iter().all(|k| !k.contains("o'"))); } @@ -2169,7 +2228,7 @@ mod tests { fn json_entry_type_is_derived_from_the_catalog() { // Not a hardcoded literal: a catalog rename or PUBLIC_TYPNAME_PREFIX bump // must flow through rather than silently drift (cf. #398 jsonb -> json). - assert_eq!(json_entry_type(), "public.eql_v3_json_entry"); + assert_eq!(json_entry_type(), "public.{{prefix}}_json_entry"); assert_eq!(json_entry_stem("integer"), "json_entry_integer"); assert_eq!( json_entry_functions_path("integer"), diff --git a/packages/eql/crates/eql-codegen/src/lib.rs b/packages/eql/crates/eql-codegen/src/lib.rs index 03cdf3e48..49f5c9946 100644 --- a/packages/eql/crates/eql-codegen/src/lib.rs +++ b/packages/eql/crates/eql-codegen/src/lib.rs @@ -15,6 +15,7 @@ pub mod generate; pub mod go_eql; pub mod operator_surface; pub mod ordering; +pub mod render; pub mod targets; pub mod writer; diff --git a/packages/eql/crates/eql-codegen/src/main.rs b/packages/eql/crates/eql-codegen/src/main.rs index 2dc95b195..c4d9f4bac 100644 --- a/packages/eql/crates/eql-codegen/src/main.rs +++ b/packages/eql/crates/eql-codegen/src/main.rs @@ -117,6 +117,33 @@ fn main() -> ExitCode { } } + // `render <3|4> ...`: write each placeholder source file + // (relative to the working directory) as that EQL version, to the same + // relative path under . Consumed by tasks/build.sh, which renders + // the ordered surface and assembles the installer from the result. + if args.len() >= 4 && args[1] == "render" { + let version = match args[2].parse::() { + Ok(v) => v, + Err(e) => { + eprintln!("error: {e}"); + return ExitCode::from(2); + } + }; + let files: Vec = args[4..].iter().map(PathBuf::from).collect(); + return match eql_codegen::render::render_files( + std::path::Path::new("."), + &files, + std::path::Path::new(&args[3]), + version, + ) { + Ok(()) => ExitCode::SUCCESS, + Err(e) => { + eprintln!("error: {e}"); + ExitCode::FAILURE + } + }; + } + // `clean`: remove the generated SQL surface (marker-aware) under every // src/v3/scalars/* type dir. Replaces build.sh's filename-pattern sweep; // hand-written files (no AUTO-GENERATED marker) are preserved. @@ -152,6 +179,7 @@ fn main() -> ExitCode { eprintln!("Usage: eql-codegen (generate all types)"); eprintln!(" eql-codegen order (print the src/v3 install order, one path per line)"); eprintln!(" eql-codegen clean (remove the generated SQL surface)"); + eprintln!(" eql-codegen render <3|4> ... (render placeholder SQL as one EQL version)"); eprintln!(" eql-codegen list-types (print catalog tokens)"); eprintln!(" eql-codegen list-schemas (print owned schemas, public first)"); eprintln!(" eql-codegen dump-catalog (print catalog surface as JSON)"); diff --git a/packages/eql/crates/eql-codegen/src/render.rs b/packages/eql/crates/eql-codegen/src/render.rs new file mode 100644 index 000000000..c9b4ee8b4 --- /dev/null +++ b/packages/eql/crates/eql-codegen/src/render.rs @@ -0,0 +1,290 @@ +//! Renders the EQL SQL source as one EQL version. +//! +//! The SQL under `src/v3` names its schemas and its payload version by +//! placeholder, never literally, so one source can be written out under two +//! names (ADR-0002): `eql_v3` for cipherstash-client's terms and `eql_v4` for +//! Stack Encrypt's. Postgres then refuses to compare a query term of one with a +//! column of the other, at plan time. +//! +//! | placeholder | `eql_v3` | `eql_v4` | +//! |-------------------|----------|----------| +//! | `{{prefix}}` | `eql_v3` | `eql_v4` | +//! | `{{eql_version}}` | `3` | `4` | +//! +//! `{{prefix}}` is both the schema (`{{prefix}}.eq_term`) and the start of every +//! other name (`{{prefix}}_internal`, `public.{{prefix}}_text_eq`). +//! +//! Rendering is strict in both directions. An unknown or unterminated +//! placeholder is an error, and so is a literal `eql_v3` or `eql_v4` in the +//! source: a literal name would render the same in both outputs, so the `eql_v4` +//! bundle would quietly reach into `eql_v3`. + +use std::fmt; +use std::fs; +use std::io; +use std::path::{Path, PathBuf}; + +/// The schema-and-name prefix placeholder. +pub const PREFIX: &str = "{{prefix}}"; + +/// The payload-version placeholder. +pub const EQL_VERSION: &str = "{{eql_version}}"; + +/// An EQL version the source can be rendered as. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum EqlVersion { + /// `eql_v3`: payloads and terms written by cipherstash-client. + V3, + /// `eql_v4`: payloads and terms written by Stack Encrypt. + V4, +} + +impl EqlVersion { + /// Every version, in release order. + pub const ALL: [EqlVersion; 2] = [EqlVersion::V3, EqlVersion::V4]; + + /// The payload version, as the domain CHECKs compare it: `"3"` or `"4"`. + pub fn number(self) -> &'static str { + match self { + EqlVersion::V3 => "3", + EqlVersion::V4 => "4", + } + } + + /// The schema and name prefix: `eql_v3` or `eql_v4`. + pub fn prefix(self) -> &'static str { + match self { + EqlVersion::V3 => "eql_v3", + EqlVersion::V4 => "eql_v4", + } + } +} + +impl std::str::FromStr for EqlVersion { + type Err = String; + + fn from_str(s: &str) -> Result { + EqlVersion::ALL + .into_iter() + .find(|v| v.number() == s) + .ok_or_else(|| format!("unknown EQL version {s:?} (expected 3 or 4)")) + } +} + +/// Why a source could not be rendered. `line` is 1-based. +#[derive(Debug, PartialEq, Eq)] +pub enum RenderError { + /// `{{name}}` where `name` is not a placeholder this renderer knows. + UnknownPlaceholder { line: usize, name: String }, + /// `{{` with no closing `}}` on the same line. + Unterminated { line: usize }, + /// A literal `eql_v3` or `eql_v4` where a placeholder belongs. + LiteralName { line: usize, literal: &'static str }, +} + +impl fmt::Display for RenderError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + RenderError::UnknownPlaceholder { line, name } => write!( + f, + "line {line}: unknown placeholder {{{{{name}}}}} (expected {PREFIX} or {EQL_VERSION})" + ), + RenderError::Unterminated { line } => { + write!(f, "line {line}: `{{{{` with no closing `}}}}`") + } + RenderError::LiteralName { line, literal } => write!( + f, + "line {line}: literal `{literal}`; write {PREFIX} so the name follows the EQL version" + ), + } + } +} + +impl std::error::Error for RenderError {} + +/// Render one source text as `version`. +pub fn render_str(src: &str, version: EqlVersion) -> Result { + let mut out = String::with_capacity(src.len()); + for (i, line) in src.split_inclusive('\n').enumerate() { + let lineno = i + 1; + for v in EqlVersion::ALL { + if line.contains(v.prefix()) { + return Err(RenderError::LiteralName { + line: lineno, + literal: v.prefix(), + }); + } + } + let mut rest = line; + while let Some(open) = rest.find("{{") { + out.push_str(&rest[..open]); + let after = &rest[open + 2..]; + let close = after + .find("}}") + .ok_or(RenderError::Unterminated { line: lineno })?; + match &after[..close] { + "prefix" => out.push_str(version.prefix()), + "eql_version" => out.push_str(version.number()), + other => { + return Err(RenderError::UnknownPlaceholder { + line: lineno, + name: other.to_string(), + }) + } + } + rest = &after[close + 2..]; + } + out.push_str(rest); + } + Ok(out) +} + +/// Why a file could not be rendered. +#[derive(Debug)] +pub enum RenderFileError { + Io { path: PathBuf, source: io::Error }, + Render { path: PathBuf, source: RenderError }, +} + +impl fmt::Display for RenderFileError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + RenderFileError::Io { path, source } => write!(f, "{}: {source}", path.display()), + RenderFileError::Render { path, source } => { + write!(f, "{}: {source}", path.display()) + } + } + } +} + +impl std::error::Error for RenderFileError {} + +/// Render each of `files` (relative to `root`) as `version`, writing it to the +/// same relative path under `out`. Every file is rendered before any is +/// written, so a source error leaves `out` as it was. +pub fn render_files( + root: &Path, + files: &[PathBuf], + out: &Path, + version: EqlVersion, +) -> Result<(), RenderFileError> { + let mut rendered = Vec::with_capacity(files.len()); + for rel in files { + let path = root.join(rel); + let src = fs::read_to_string(&path).map_err(|source| RenderFileError::Io { + path: path.clone(), + source, + })?; + let body = render_str(&src, version).map_err(|source| RenderFileError::Render { + path: path.clone(), + source, + })?; + rendered.push((out.join(rel), body)); + } + for (dest, body) in rendered { + if let Some(parent) = dest.parent() { + fs::create_dir_all(parent).map_err(|source| RenderFileError::Io { + path: parent.to_path_buf(), + source, + })?; + } + fs::write(&dest, body).map_err(|source| RenderFileError::Io { path: dest, source })?; + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + const SRC: &str = "CREATE DOMAIN public.{{prefix}}_text_eq AS jsonb\n \ + CHECK (VALUE->>'v' = '{{eql_version}}');\n\ + SELECT {{prefix}}_internal.f({{prefix}}.g());\n"; + + #[test] + fn renders_v3() { + assert_eq!( + render_str(SRC, EqlVersion::V3).unwrap(), + "CREATE DOMAIN public.eql_v3_text_eq AS jsonb\n \ + CHECK (VALUE->>'v' = '3');\n\ + SELECT eql_v3_internal.f(eql_v3.g());\n" + ); + } + + #[test] + fn renders_v4() { + assert_eq!( + render_str(SRC, EqlVersion::V4).unwrap(), + "CREATE DOMAIN public.eql_v4_text_eq AS jsonb\n \ + CHECK (VALUE->>'v' = '4');\n\ + SELECT eql_v4_internal.f(eql_v4.g());\n" + ); + } + + #[test] + fn text_without_placeholders_is_unchanged() { + let src = "SELECT '{}'::jsonb, '{\"a\":1}', $$ { } $$;\n-- eql_v2 provenance\nno newline"; + assert_eq!(render_str(src, EqlVersion::V4).unwrap(), src); + } + + #[test] + fn rejects_literal_names() { + for (src, literal) in [ + ("x\nSELECT eql_v3.f();\n", "eql_v3"), + ("x\n-- eql_v4_internal\n", "eql_v4"), + ] { + assert_eq!( + render_str(src, EqlVersion::V3), + Err(RenderError::LiteralName { line: 2, literal }) + ); + } + } + + #[test] + fn rejects_unknown_placeholder() { + assert_eq!( + render_str("{{prefix}}\n{{ prefix }}\n", EqlVersion::V3), + Err(RenderError::UnknownPlaceholder { + line: 2, + name: " prefix ".to_string() + }) + ); + } + + #[test] + fn rejects_unterminated_placeholder() { + assert_eq!( + render_str("ok\n{{prefix\n}}\n", EqlVersion::V3), + Err(RenderError::Unterminated { line: 2 }) + ); + } + + #[test] + fn parses_versions() { + assert_eq!("3".parse(), Ok(EqlVersion::V3)); + assert_eq!("4".parse(), Ok(EqlVersion::V4)); + assert!("2".parse::().is_err()); + } + + #[test] + fn render_files_writes_nothing_when_any_file_fails() { + let dir = std::env::temp_dir().join(format!("eql-render-{}", std::process::id())); + let root = dir.join("root"); + let out = dir.join("out"); + fs::create_dir_all(root.join("src/v3")).unwrap(); + fs::write(root.join("src/v3/a.sql"), "SELECT {{prefix}}.f();\n").unwrap(); + fs::write(root.join("src/v3/b.sql"), "SELECT eql_v3.f();\n").unwrap(); + + let files = [PathBuf::from("src/v3/a.sql"), PathBuf::from("src/v3/b.sql")]; + let err = render_files(&root, &files, &out, EqlVersion::V4).unwrap_err(); + assert!(err.to_string().contains("b.sql"), "{err}"); + assert!(!out.exists()); + + render_files(&root, &files[..1], &out, EqlVersion::V4).unwrap(); + assert_eq!( + fs::read_to_string(out.join("src/v3/a.sql")).unwrap(), + "SELECT eql_v4.f();\n" + ); + fs::remove_dir_all(&dir).unwrap(); + } +} diff --git a/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2 b/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2 index ce27234cf..5c349bff7 100644 --- a/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2 +++ b/packages/eql/crates/eql-codegen/templates/ore_fallback.sql.j2 @@ -8,7 +8,7 @@ --! --! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql, --! which ATTEMPTS to create the default btree operator class for ---! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege +--! {{ internal_schema }}.ore_block_256 and skips it on insufficient_privilege --! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud --! Supabase and most hosted Postgres — run the installer as a non-superuser --! role). When the class was created, this file is a no-op. diff --git a/packages/eql/crates/eql-codegen/templates/query_types.sql.j2 b/packages/eql/crates/eql-codegen/templates/query_types.sql.j2 index 2dee7bf01..eb93b0266 100644 --- a/packages/eql/crates/eql-codegen/templates/query_types.sql.j2 +++ b/packages/eql/crates/eql-codegen/templates/query_types.sql.j2 @@ -33,7 +33,7 @@ BEGIN AND jsonb_typeof(VALUE -> '{{ k }}') = 'array' AND jsonb_array_length(VALUE -> '{{ k }}') > 0 {%- endfor %} - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{ eql_version }}' ); END IF; diff --git a/packages/eql/crates/eql-codegen/templates/types.sql.j2 b/packages/eql/crates/eql-codegen/templates/types.sql.j2 index cc854121c..82a0d5085 100644 --- a/packages/eql/crates/eql-codegen/templates/types.sql.j2 +++ b/packages/eql/crates/eql-codegen/templates/types.sql.j2 @@ -22,7 +22,7 @@ BEGIN AND jsonb_typeof(VALUE -> '{{ k }}') = 'array' AND jsonb_array_length(VALUE -> '{{ k }}') > 0 {%- endfor %} - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{ eql_version }}' ); END IF; diff --git a/packages/eql/crates/eql-codegen/tests/cli.rs b/packages/eql/crates/eql-codegen/tests/cli.rs index 4299ca989..2d3534fa9 100644 --- a/packages/eql/crates/eql-codegen/tests/cli.rs +++ b/packages/eql/crates/eql-codegen/tests/cli.rs @@ -81,7 +81,7 @@ fn list_schemas_subcommand_prints_owned_schemas() { ); let stdout = String::from_utf8_lossy(&out.stdout); assert_eq!( - stdout, "eql_v3\neql_v3_internal\n", + stdout, "{{prefix}}\n{{prefix}}_internal\n", "list-schemas must print the public schema first, then the internal schema" ); } diff --git a/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md b/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md index 79f7fad25..da7e425bf 100644 --- a/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md +++ b/packages/eql/docs/reference/adding-a-scalar-encrypted-domain-type.md @@ -756,14 +756,18 @@ lists, headers, or cleans it; it must declare its own `-- REQUIRE:` edges (usually to `_types.sql` and whichever generated function or operator file it extends). Use it for cross-domain casts, helper functions, or type-specific constraints. Unlike the generated siblings, **`_extensions.sql` IS -committed.** (Neither `integer` nor `smallint` ships one today.) +committed.** (Neither `integer` nor `smallint` ships one today.) Like every +file under `src/v3`, it names schemas and the payload version by placeholder: +`{{prefix}}.eq_term`, `public.{{prefix}}_integer_eq`, +`VALUE->>'v' = '{{eql_version}}'`. The build rejects a literal `eql_v3`. See +"Schema and version placeholders" in `AGENTS.md`. `tasks/pin_search_path_v3.sql` describes the fallback marker for inline-critical extension functions that take no domain argument and so escape the structural skip: ```sql -COMMENT ON FUNCTION eql_v3.my_helper(...) IS 'eql-inline-critical: ...'; +COMMENT ON FUNCTION {{prefix}}.my_helper(...) IS 'eql-inline-critical: ...'; ``` The generator never emits this marker; every function it produces takes a domain diff --git a/packages/eql/mise.toml b/packages/eql/mise.toml index f4bbd55f6..4eb97643c 100644 --- a/packages/eql/mise.toml +++ b/packages/eql/mise.toml @@ -244,14 +244,14 @@ depends = ["build"] dir = "{{config_root}}" run = """ bash tasks/test/symbol_order_selftest.sh -bash tasks/test/verify_symbol_order_v3.sh src/deps-ordered-v3.txt +bash tasks/test/verify_symbol_order_v3.sh build/render/eql_v3/deps-ordered.txt """ [tasks."test:installer_complete"] description = "Assert the installer contains every ordered src/v3 file's body (DB-free)" depends = ["build"] dir = "{{config_root}}" -run = "bash tasks/test/verify_installer_complete.sh src/deps-ordered-v3.txt release/cipherstash-encrypt.sql" +run = "bash tasks/test/verify_installer_complete.sh build/render/eql_v3/deps-ordered.txt release/cipherstash-encrypt.sql build/render/eql_v3" [tasks."test:build_ordering_helpers"] description = "Unit tests for tasks/build/ordering.sh strip_require_lines (DB-free)" diff --git a/packages/eql/src/v3/aggregates.sql b/packages/eql/src/v3/aggregates.sql index 93402386f..c7f45c64c 100644 --- a/packages/eql/src/v3/aggregates.sql +++ b/packages/eql/src/v3/aggregates.sql @@ -3,7 +3,7 @@ --! @file v3/aggregates.sql --! @brief Aggregates for grouping and deduplicating encrypted values. --! ---! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY` +--! Provides `{{prefix}}.grouped_value` — the aggregate you need to run a `GROUP BY` --! over an encrypted column and still get the encrypted value back. --! --! ## Grouping encrypted values @@ -11,13 +11,13 @@ --! Encryption in EQL is non-deterministic: encrypting the same value twice gives --! two different ciphertexts. So you cannot group rows by comparing the stored --! ciphertext. Instead you group by the column's *equality term*, ---! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal +--! `{{prefix}}.eq_term(col)` — a deterministic keyed hash that is identical for equal --! plaintexts. Counting how many rows share each encrypted value looks like this --! (the term itself is opaque, so there is no reason to select it): --! --! SELECT count(*) --! FROM users ---! GROUP BY eql_v3.eq_term(email); +--! GROUP BY {{prefix}}.eq_term(email); --! --! The equality term is opaque, though — you usually want the encrypted value --! itself back so your application can decrypt it. Adding the column to the @@ -25,17 +25,17 @@ --! --! SELECT email, count(*) -- email is not in GROUP BY --! FROM users ---! GROUP BY eql_v3.eq_term(email); +--! GROUP BY {{prefix}}.eq_term(email); --! -- ERROR: column "email" must appear in the GROUP BY clause or be used in --! -- an aggregate function --! --! Every row in a group is an encryption of the same plaintext, so any one of ---! them represents the group. `eql_v3.grouped_value` is the aggregate that hands +--! them represents the group. `{{prefix}}.grouped_value` is the aggregate that hands --! one back: --! ---! SELECT eql_v3.grouped_value(email) AS email, count(*) +--! SELECT {{prefix}}.grouped_value(email) AS email, count(*) --! FROM users ---! GROUP BY eql_v3.eq_term(email); +--! GROUP BY {{prefix}}.eq_term(email); --! --! ## Deduplicating without an aggregate --! @@ -43,11 +43,11 @@ --! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality --! term, which lets you project the column directly: --! ---! SELECT DISTINCT ON (eql_v3.eq_term(email)) email +--! SELECT DISTINCT ON ({{prefix}}.eq_term(email)) email --! FROM users ---! ORDER BY eql_v3.eq_term(email); +--! ORDER BY {{prefix}}.eq_term(email); --! ---! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain +--! Deduplicate on `{{prefix}}.eq_term(col)`, never on the column itself: a plain --! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the --! same value are NOT collapsed. --! @@ -75,8 +75,8 @@ --! @param value jsonb New value from the current row. --! @return jsonb The running state (first non-null value). --! ---! @see eql_v3.grouped_value -CREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb) +--! @see {{prefix}}.grouped_value +CREATE FUNCTION {{prefix}}_internal.grouped_value_sfunc(state jsonb, value jsonb) RETURNS jsonb LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -90,9 +90,9 @@ $$; --! --! Returns the first non-null value encountered within a `GROUP BY` group. Its --! primary use is projecting an encrypted column while grouping by that column's ---! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let +--! equality term (`GROUP BY {{prefix}}.eq_term(col)`), where PostgreSQL will not let --! you `SELECT col` directly — see the file header for the worked example. ---! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and +--! Accepts any {{prefix}} encrypted-domain value (each is a jsonb-backed domain) and --! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE` --! with a combine function, so it works under partial/parallel aggregation on --! large `GROUP BY` workloads. @@ -107,22 +107,22 @@ $$; --! matches the eql_v2 original. --! --! Group encrypted rows by encrypted equality and project the encrypted ---! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term; +--! column. GROUP BY {{prefix}}.eq_term(...) groups by the HMAC equality term; --! grouped_value(...) returns a representative ciphertext for each group so --! PostgreSQL does not reject the bare column reference. --! --! @code{.sql} ---! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo, +--! SELECT {{prefix}}.grouped_value(encrypted_foo) AS encrypted_foo, --! count(*) --! FROM some_table ---! GROUP BY eql_v3.eq_term(encrypted_foo); +--! GROUP BY {{prefix}}.eq_term(encrypted_foo); --! @endcode --! ---! @see eql_v3_internal.grouped_value_sfunc ---! @see eql_v3.eq_term -CREATE AGGREGATE eql_v3.grouped_value(jsonb) ( - sfunc = eql_v3_internal.grouped_value_sfunc, +--! @see {{prefix}}_internal.grouped_value_sfunc +--! @see {{prefix}}.eq_term +CREATE AGGREGATE {{prefix}}.grouped_value(jsonb) ( + sfunc = {{prefix}}_internal.grouped_value_sfunc, stype = jsonb, - combinefunc = eql_v3_internal.grouped_value_sfunc, + combinefunc = {{prefix}}_internal.grouped_value_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/common.sql b/packages/eql/src/v3/common.sql index a81ea3724..56c0edc33 100644 --- a/packages/eql/src/v3/common.sql +++ b/packages/eql/src/v3/common.sql @@ -1,9 +1,9 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/common.sql ---! @brief Common utility functions for the self-contained eql_v3 surface. +--! @brief Common utility functions for the self-contained {{prefix}} surface. --! ---! Forked from src/common.sql (design D7) so the eql_v3 ORE constructor owns the +--! Forked from src/common.sql (design D7) so the {{prefix}} ORE constructor owns the --! one transitive helper it needs without reaching into another schema. The --! eql_v2 original is unchanged. @@ -29,7 +29,7 @@ --! raised) — both callers only ever pass an array or JSON null (`val->'ob'`), --! so the divergence stays unreachable in practice; JSON null and empty --! array still return NULL exactly as before. -CREATE FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(val jsonb) +CREATE FUNCTION {{prefix}}_internal.jsonb_array_to_bytea_array(val jsonb) RETURNS bytea[] IMMUTABLE AS $$ @@ -53,5 +53,5 @@ $$ LANGUAGE plpgsql; --! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the --! structural skip in tasks/pin_search_path_v3.sql does not recognise it; --! this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_bytea_array(jsonb) IS +COMMENT ON FUNCTION {{prefix}}_internal.jsonb_array_to_bytea_array(jsonb) IS 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; diff --git a/packages/eql/src/v3/crypto.sql b/packages/eql/src/v3/crypto.sql index bd99b1627..24e0662f2 100644 --- a/packages/eql/src/v3/crypto.sql +++ b/packages/eql/src/v3/crypto.sql @@ -1,11 +1,11 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/crypto.sql ---! @brief PostgreSQL pgcrypto extension enablement (eql_v3 fork) +--! @brief PostgreSQL pgcrypto extension enablement ({{prefix}} fork) --! ---! Forked from src/crypto.sql (design D8) so the entire eql_v3 dependency +--! Forked from src/crypto.sql (design D8) so the entire {{prefix}} dependency --! closure lives under src/v3/. Enables the pgcrypto extension which provides ---! cryptographic functions used by the eql_v3 ORE comparison path. +--! cryptographic functions used by the {{prefix}} ORE comparison path. --! --! Installs pgcrypto into the `extensions` schema (Supabase convention) to --! avoid the `extension_in_public` lint. Every EQL function that uses pgcrypto diff --git a/packages/eql/src/v3/json/aggregates.sql b/packages/eql/src/v3/json/aggregates.sql index 1d4d9ad86..50621e353 100644 --- a/packages/eql/src/v3/json/aggregates.sql +++ b/packages/eql/src/v3/json/aggregates.sql @@ -3,11 +3,11 @@ -- REQUIRE: src/v3/sem/ope_cllw/types.sql --! @file v3/json/aggregates.sql ---! @brief min / max aggregates over public.eql_v3_json_entry. +--! @brief min / max aggregates over public.{{prefix}}_json_entry. --! --! SteVec document entries extracted at a selector (`doc -> 'sel'`) order by --! their CLLW OPE (`op`) term, so the extremum is picked by comparing ---! `eql_v3.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the +--! `{{prefix}}.ord_term(entry)` rather than the scalar Block-ORE `ord_term` the --! generated scalar ord aggregates use. The ope_cllw bytea domain orders under --! native byte comparison, so `<` / `>` on the extracted terms needs no custom --! comparator. Same STRICT + PARALLEL SAFE shape as the generated scalar @@ -18,9 +18,9 @@ --! `LANGUAGE plpgsql` with the pinned `search_path` — a `LANGUAGE sql` body would --! be inlinable and the planner could elide it. --! ---! @note **Only `op`-carrying entries are orderable.** `eql_v3.ord_term(entry)` +--! @note **Only `op`-carrying entries are orderable.** `{{prefix}}.ord_term(entry)` --! returns NULL when an entry has no `op` (CLLW OPE) term — the same entries a ---! `eql_v3.ord_term` btree NULL-filters from range scans. The state functions +--! `{{prefix}}.ord_term` btree NULL-filters from range scans. The state functions --! therefore IGNORE `op`-less entries (they never become or survive as the --! extremum), so `min`/`max` is well-defined over a mix of `op`-carrying and --! `op`-less entries and is not corrupted by an `op`-less seed. A naive @@ -29,26 +29,26 @@ --! row is `op`-less. An all-`op`-less input has no orderable extremum and --! returns the (arbitrary) STRICT seed. ---! @brief State function for min on public.eql_v3_json_entry. +--! @brief State function for min on public.{{prefix}}_json_entry. --! --! Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL --! NULL entries are skipped by the aggregate machinery; `op`-less (non-orderable) --! entries are skipped explicitly (see the @note on this file). --! ---! @param state public.eql_v3_json_entry Running extremum. ---! @param value public.eql_v3_json_entry Candidate entry. ---! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc( - state public.eql_v3_json_entry, - value public.eql_v3_json_entry +--! @param state public.{{prefix}}_json_entry Running extremum. +--! @param value public.{{prefix}}_json_entry Candidate entry. +--! @return public.{{prefix}}_json_entry The lesser orderable entry by `ord_term`. +CREATE FUNCTION {{prefix}}_internal.jsonb_entry_min_sfunc( + state public.{{prefix}}_json_entry, + value public.{{prefix}}_json_entry ) -RETURNS public.eql_v3_json_entry +RETURNS public.{{prefix}}_json_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); + value_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(value); + state_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(state); BEGIN -- A non-orderable (op-less) candidate never replaces the running extremum. IF value_ope IS NULL THEN @@ -63,35 +63,35 @@ BEGIN END; $$; ---! @brief min aggregate over public.eql_v3_json_entry. ---! @param input public.eql_v3_json_entry ---! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term. -CREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) ( - sfunc = eql_v3_internal.jsonb_entry_min_sfunc, - stype = public.eql_v3_json_entry, - combinefunc = eql_v3_internal.jsonb_entry_min_sfunc, +--! @brief min aggregate over public.{{prefix}}_json_entry. +--! @param input public.{{prefix}}_json_entry +--! @return public.{{prefix}}_json_entry The entry with the smallest CLLW OPE term. +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_json_entry) ( + sfunc = {{prefix}}_internal.jsonb_entry_min_sfunc, + stype = public.{{prefix}}_json_entry, + combinefunc = {{prefix}}_internal.jsonb_entry_min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_json_entry. +--! @brief State function for max on public.{{prefix}}_json_entry. --! --! Keeps whichever orderable entry has the greater CLLW OPE term. `op`-less --! entries are skipped, mirroring `jsonb_entry_min_sfunc` (see the file @note). --! ---! @param state public.eql_v3_json_entry Running extremum. ---! @param value public.eql_v3_json_entry Candidate entry. ---! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`. -CREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc( - state public.eql_v3_json_entry, - value public.eql_v3_json_entry +--! @param state public.{{prefix}}_json_entry Running extremum. +--! @param value public.{{prefix}}_json_entry Candidate entry. +--! @return public.{{prefix}}_json_entry The greater orderable entry by `ord_term`. +CREATE FUNCTION {{prefix}}_internal.jsonb_entry_max_sfunc( + state public.{{prefix}}_json_entry, + value public.{{prefix}}_json_entry ) -RETURNS public.eql_v3_json_entry +RETURNS public.{{prefix}}_json_entry LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ DECLARE - value_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(value); - state_ope eql_v3_internal.ope_cllw := eql_v3.ord_term(state); + value_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(value); + state_ope {{prefix}}_internal.ope_cllw := {{prefix}}.ord_term(state); BEGIN -- A non-orderable (op-less) candidate never replaces the running extremum. IF value_ope IS NULL THEN @@ -106,12 +106,12 @@ BEGIN END; $$; ---! @brief max aggregate over public.eql_v3_json_entry. ---! @param input public.eql_v3_json_entry ---! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term. -CREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) ( - sfunc = eql_v3_internal.jsonb_entry_max_sfunc, - stype = public.eql_v3_json_entry, - combinefunc = eql_v3_internal.jsonb_entry_max_sfunc, +--! @brief max aggregate over public.{{prefix}}_json_entry. +--! @param input public.{{prefix}}_json_entry +--! @return public.{{prefix}}_json_entry The entry with the largest CLLW OPE term. +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_json_entry) ( + sfunc = {{prefix}}_internal.jsonb_entry_max_sfunc, + stype = public.{{prefix}}_json_entry, + combinefunc = {{prefix}}_internal.jsonb_entry_max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/json/blockers.sql b/packages/eql/src/v3/json/blockers.sql index 935bc3105..cd9ee7b01 100644 --- a/packages/eql/src/v3/json/blockers.sql +++ b/packages/eql/src/v3/json/blockers.sql @@ -3,10 +3,10 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file v3/json/blockers.sql ---! @brief Native-jsonb firewall for public.eql_v3_json_search. +--! @brief Native-jsonb firewall for public.{{prefix}}_json_search. --! ---! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons ---! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry; +--! public.{{prefix}}_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons +--! Ordered comparisons < <= > >= are supported on public.{{prefix}}_json_entry; --! entry equality = <> is blocked because path entries carry no exact value --! selector. Root-document comparisons are also blocked. --! Every OTHER native jsonb operator reachable via domain fallback against the @@ -16,7 +16,7 @@ --! --! Each blocker is LANGUAGE plpgsql (NEVER STRICT — a STRICT blocker would let --! PostgreSQL skip the body and return NULL on a NULL argument, bypassing the ---! exception) and delegates to the shared eql_v3.encrypted_domain_unsupported_* +--! exception) and delegates to the shared {{prefix}}.encrypted_domain_unsupported_* --! helpers. Each blocker's RETURNS type matches the native operator it shadows --! (#> -> jsonb, #>> -> text, - / #- / || -> jsonb; the rest are boolean) so a --! composed expression resolves and the body raises 'operator not supported', @@ -25,417 +25,417 @@ --! so the firewall fires. --! @brief Blocker: ? (key/element exists). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists(a public.eql_v3_json_search, b text) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists(a public.{{prefix}}_json_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_exists, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text ); --! @brief Blocker: ?| (any key exists). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_any(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists_any(a public.{{prefix}}_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?|'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?|'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_any, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_exists_any, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: ?& (all keys exist). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_exists_all(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_exists_all(a public.{{prefix}}_json_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '?&'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '?&'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal.jsonb_blocked_exists_all, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_exists_all, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: @? (jsonpath exists). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_exists(a public.eql_v3_json_search, b jsonpath) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_jsonpath_exists(a public.{{prefix}}_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@?'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@?'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_jsonpath_exists, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: @@ (jsonpath predicate). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonpath Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_jsonpath_match(a public.eql_v3_json_search, b jsonpath) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_jsonpath_match(a public.{{prefix}}_json_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@@'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_jsonpath_match, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonpath ); --! @brief Blocker: #> (path extract, native returns jsonb). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_path_extract(a public.{{prefix}}_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '#>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_path_extract, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: #>> (path extract as text). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return text Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_path_extract_text(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_path_extract_text(a public.{{prefix}}_json_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_text('public.eql_v3_json_search', '#>>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_text('public.{{prefix}}_json_search', '#>>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_path_extract_text, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: - (delete key, text RHS; native returns jsonb). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_text(a public.eql_v3_json_search, b text) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_text(a public.{{prefix}}_json_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_text, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_text, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text ); --! @brief Blocker: - (delete index, integer RHS). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b integer Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_int(a public.eql_v3_json_search, b integer) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_int(a public.{{prefix}}_json_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_int, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_int, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = integer ); --! @brief Blocker: - (delete keys, text[] RHS). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_array(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_array(a public.{{prefix}}_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '-'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR - ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_array, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_array, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: #- (delete at path). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b text[] Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_delete_path(a public.eql_v3_json_search, b text[]) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_delete_path(a public.{{prefix}}_json_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '#-'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '#-'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal.jsonb_blocked_delete_path, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_delete_path, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = text[] ); --! @brief Blocker: || (concatenate, encrypted on the left). ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat(a public.eql_v3_json_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_concat(a public.{{prefix}}_json_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_concat, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); --! @brief Blocker: || (concatenate, encrypted on the right). --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json_search Right operand (encrypted payload). +--! @param b public.{{prefix}}_json_search Right operand (encrypted payload). --! @return jsonb Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_concat_rhs(a jsonb, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_concat_rhs(a jsonb, b public.{{prefix}}_json_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_jsonb('public.eql_v3_json_search', '||'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_jsonb('public.{{prefix}}_json_search', '||'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR || ( - FUNCTION = eql_v3_internal.jsonb_blocked_concat_rhs, + FUNCTION = {{prefix}}_internal.jsonb_blocked_concat_rhs, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); ------------------------------------------------------------------------------ -- Root-document comparison blockers. ------------------------------------------------------------------------------ ---! @brief Blocker: root public.eql_v3_json_search document comparisons. ---! @param a public.eql_v3_json_search Left operand (encrypted payload). ---! @param b public.eql_v3_json_search Right operand (encrypted payload). +--! @brief Blocker: root public.{{prefix}}_json_search document comparisons. +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). +--! @param b public.{{prefix}}_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_json(a public.eql_v3_json_search, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_json_json(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons. ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @brief Blocker: root public.{{prefix}}_json_search-to-jsonb comparisons. +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_json_jsonb(a public.eql_v3_json_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_json_jsonb(a public.{{prefix}}_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; ---! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons. +--! @brief Blocker: root jsonb-to-public.{{prefix}}_json_search comparisons. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json_search Right operand (encrypted payload). +--! @param b public.{{prefix}}_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_compare_jsonb_json(a jsonb, b public.{{prefix}}_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', 'comparison'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', 'comparison'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_json, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.jsonb_blocked_compare_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_compare_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); ------------------------------------------------------------------------------ @@ -443,46 +443,46 @@ CREATE OPERATOR >= ( ------------------------------------------------------------------------------ --! @brief Block document containment against an extracted path entry. ---! @param a public.eql_v3_json_search Encrypted document. ---! @param b public.eql_v3_json_entry Extracted path entry. +--! @param a public.{{prefix}}_json_search Encrypted document. +--! @param b public.{{prefix}}_json_entry Extracted path entry. --! @return boolean Never returns; always raises 'operator not supported'. --! @note An extracted path entry carries no value selector, so this signature --! cannot express exact equality. It is explicitly claimed to prevent --! PostgreSQL flattening both domains to native jsonb containment. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_entry(a public.{{prefix}}_json_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry, - LEFTARG = public.eql_v3_json_search, - RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_entry, + LEFTARG = public.{{prefix}}_json_search, + RIGHTARG = public.{{prefix}}_json_entry ); --! @brief Block reverse containment from an extracted path entry. ---! @param a public.eql_v3_json_entry Extracted path entry. ---! @param b public.eql_v3_json_search Encrypted document. +--! @param a public.{{prefix}}_json_entry Extracted path entry. +--! @param b public.{{prefix}}_json_search Encrypted document. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_entry_contained(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<@'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_search + FUNCTION = {{prefix}}_internal.jsonb_blocked_entry_contained, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_search ); ------------------------------------------------------------------------------ @@ -490,81 +490,81 @@ CREATE OPERATOR <@ ( ------------------------------------------------------------------------------ --! @brief Blocker: @> with encrypted root document and native jsonb. ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_json_jsonb(a public.eql_v3_json_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_json_jsonb(a public.{{prefix}}_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: @> with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json_search Right operand (encrypted payload). +--! @param b public.{{prefix}}_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contains_jsonb_json(a jsonb, b public.{{prefix}}_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '@>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '@>'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with encrypted root document and native jsonb. ---! @param a public.eql_v3_json_search Left operand (encrypted payload). +--! @param a public.{{prefix}}_json_search Left operand (encrypted payload). --! @param b jsonb Native RHS operand. --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_json_jsonb(a public.eql_v3_json_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contained_json_jsonb(a public.{{prefix}}_json_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '<@'); END; $$ LANGUAGE plpgsql; --! @brief Blocker: <@ with native jsonb and encrypted root document. --! @param a jsonb Native LHS operand. ---! @param b public.eql_v3_json_search Right operand (encrypted payload). +--! @param b public.{{prefix}}_json_search Right operand (encrypted payload). --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}_internal.jsonb_blocked_contained_jsonb_json(a jsonb, b public.{{prefix}}_json_search) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_search', '<@'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_search', '<@'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.jsonb_blocked_contains_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_contains_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb, - LEFTARG = public.eql_v3_json_search, + FUNCTION = {{prefix}}_internal.jsonb_blocked_contained_json_jsonb, + LEFTARG = public.{{prefix}}_json_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.jsonb_blocked_contained_jsonb_json, + FUNCTION = {{prefix}}_internal.jsonb_blocked_contained_jsonb_json, LEFTARG = jsonb, - RIGHTARG = public.eql_v3_json_search + RIGHTARG = public.{{prefix}}_json_search ); diff --git a/packages/eql/src/v3/json/functions.sql b/packages/eql/src/v3/json/functions.sql index fa8acdc2f..d8ba0e59c 100644 --- a/packages/eql/src/v3/json/functions.sql +++ b/packages/eql/src/v3/json/functions.sql @@ -5,14 +5,14 @@ --! @file v3/json/functions.sql --! @brief Extractors, containment engine, and path/array functions for the ---! eql_v3 encrypted-JSONB (SteVec) surface. +--! {{prefix}} encrypted-JSONB (SteVec) surface. --! --! `selector` parameters here are *encrypted-side* selector hashes — the --! deterministic hash the crypto layer emits in the `s` field of each sv --! element. Plaintext JSONPaths are never accepted at runtime. ------------------------------------------------------------------------------ --- Envelope helpers (eql_v3 owns these; jsonb-only) +-- Envelope helpers ({{prefix}} owns these; jsonb-only) ------------------------------------------------------------------------------ --! @brief Extract envelope metadata (i, v, h) from a raw jsonb encrypted value. @@ -20,7 +20,7 @@ --! `h` is the document's key header — hoisted once to the envelope because --! every sv entry encrypts under the document's single data key. Grafting it --! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`) ---! is what keeps an extracted `public.eql_v3_json_entry` self-contained +--! is what keeps an extracted `public.{{prefix}}_json_entry` self-contained --! decryptable: decryption needs the header plus the entry's own `s` (the --! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the --! keys entirely on payloads that lack them (e.g. a raw scalar envelope has @@ -28,7 +28,7 @@ --! --! @param val jsonb encrypted EQL payload --! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`. -CREATE FUNCTION eql_v3.meta_data(val jsonb) +CREATE FUNCTION {{prefix}}.meta_data(val jsonb) RETURNS jsonb IMMUTABLE STRICT PARALLEL SAFE LANGUAGE SQL @@ -38,7 +38,7 @@ AS $$ ); $$; -COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS +COMMENT ON FUNCTION {{prefix}}.meta_data(jsonb) IS 'eql-inline-critical: raw-jsonb envelope helper used by v3 jsonb wrappers; must stay inlinable (unpinned search_path)'; --! @brief Extract ciphertext (c) from a raw jsonb encrypted value. @@ -48,9 +48,9 @@ COMMENT ON FUNCTION eql_v3.meta_data(jsonb) IS --! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT --! decryptable on its own: the decryption unit is the entry — its `s` --! (nonce source), `c`, and the document key header `h` (grafted onto ---! extracted entries by `->`; see eql_v3.meta_data). Scalar payloads' +--! extracted entries by `->`; see {{prefix}}.meta_data). Scalar payloads' --! `c` remains a self-describing encrypted record. -CREATE FUNCTION eql_v3.ciphertext(val jsonb) +CREATE FUNCTION {{prefix}}.ciphertext(val jsonb) RETURNS text IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -71,7 +71,7 @@ $$ LANGUAGE plpgsql; --! @param val jsonb encrypted EQL payload --! @return text The selector value. --! @throws Exception if `s` is absent. -CREATE FUNCTION eql_v3.selector(val jsonb) +CREATE FUNCTION {{prefix}}.selector(val jsonb) RETURNS text IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -86,9 +86,9 @@ $$ LANGUAGE plpgsql; --! @brief Extract selector (s) from a ste_vec entry. The DOMAIN CHECK --! guarantees `s` is present, so this is a simple field access. ---! @param entry public.eql_v3_json_entry +--! @param entry public.{{prefix}}_json_entry --! @return text The selector value. -CREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.selector(entry public.{{prefix}}_json_entry) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -116,30 +116,30 @@ $$; --! that deliberately need encoded OPE-equivalence buckets. `hm` is retired — --! entries no longer carry it. --! ---! @param entry public.eql_v3_json_entry +--! @param entry public.{{prefix}}_json_entry --! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL). -CREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.ope_term(entry public.{{prefix}}_json_entry) RETURNS bytea LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT decode(entry ->> 'op', 'hex') $$; ---! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry). ---! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or ---! eql_v3.ord_term for ordered comparisons. This term is not an +--! @brief Deprecated compatibility alias for {{prefix}}.ope_term(json_entry). +--! @deprecated Use {{prefix}}.ope_term for raw OPE-equivalence inspection, or +--! {{prefix}}.ord_term for ordered comparisons. This term is not an --! exact equality representation. ---! @param entry public.eql_v3_json_entry +--! @param entry public.{{prefix}}_json_entry --! @return bytea Decoded `op` bytes (NULL when the entry has no `op`). -CREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.eq_term(entry public.{{prefix}}_json_entry) RETURNS bytea LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ope_term(entry) + SELECT {{prefix}}.ope_term(entry) $$; -COMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS - 'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms'; +COMMENT ON FUNCTION {{prefix}}.eq_term(public.{{prefix}}_json_entry) IS + 'DEPRECATED: use {{prefix}}.ope_term(json_entry); OPE bytes are not exact equality terms'; ------------------------------------------------------------------------------ -- CLLW OPE per-entry overload (converged with the scalar ord_term) @@ -148,24 +148,24 @@ COMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS --! @brief Extract the CLLW OPE index term from a ste_vec entry. --! --! An sv-element `op` term is only ever present on an sv element, never at a ---! root encrypted value, so the typed overload accepts public.eql_v3_json_entry — ---! the jsonb_entry twin of the generated scalar `eql_v3.ord_term` +--! root encrypted value, so the typed overload accepts public.{{prefix}}_json_entry — +--! the jsonb_entry twin of the generated scalar `{{prefix}}.ord_term` --! extractors. Returns SQL NULL when `op` is absent (the strict `->>` / --! `decode` chain propagates it), so btree NULL-filters such rows from range ---! queries. The returned eql_v3_internal.ope_cllw is a bytea domain: it orders +--! queries. The returned {{prefix}}_internal.ope_cllw is a bytea domain: it orders --! under native byte comparison with the DEFAULT btree opclass, so a ---! functional index on `eql_v3.ord_term(col -> 'selector')` engages +--! functional index on `{{prefix}}.ord_term(col -> 'selector')` engages --! structurally with no custom operator class (Supabase/managed-Postgres --! safe). --! ---! @param entry public.eql_v3_json_entry ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when +--! @param entry public.{{prefix}}_json_entry +--! @return {{prefix}}_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when --! `op` is absent. -CREATE FUNCTION eql_v3.ord_term(entry public.eql_v3_json_entry) - RETURNS eql_v3_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(entry public.{{prefix}}_json_entry) + RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.ope_cllw(entry::jsonb) + SELECT {{prefix}}_internal.ope_cllw(entry::jsonb) $$; ------------------------------------------------------------------------------ @@ -179,7 +179,7 @@ $$; --! --! @param val jsonb encrypted EQL payload --! @return jsonb[] Array of sv elements. -CREATE FUNCTION eql_v3.ste_vec(val jsonb) +CREATE FUNCTION {{prefix}}.ste_vec(val jsonb) RETURNS jsonb[] IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -205,7 +205,7 @@ $$ LANGUAGE plpgsql; --! @brief Check if a jsonb payload is marked as an sv array (`a` flag true). --! @param val jsonb encrypted EQL payload --! @return boolean True if `a` is present and true. -CREATE FUNCTION eql_v3_internal.is_ste_vec_array(val jsonb) +CREATE FUNCTION {{prefix}}_internal.is_ste_vec_array(val jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -231,7 +231,7 @@ $$ LANGUAGE plpgsql; --! --! @param val jsonb encrypted EQL payload --! @return jsonb[] Array of objects with only deterministic fields. -CREATE FUNCTION eql_v3.jsonb_array(val jsonb) +CREATE FUNCTION {{prefix}}.jsonb_array(val jsonb) RETURNS jsonb[] IMMUTABLE STRICT PARALLEL SAFE LANGUAGE SQL @@ -247,7 +247,7 @@ AS $$ ); $$; -COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_array(jsonb) IS 'eql-inline-critical: raw-jsonb deterministic-field array helper; must stay inlinable (unpinned search_path)'; ------------------------------------------------------------------------------ @@ -261,19 +261,19 @@ COMMENT ON FUNCTION eql_v3.jsonb_array(jsonb) IS --! @note Public raw-`jsonb[]` containment helper over the extracted --! deterministic fields — the function-form entrypoint for containment on --! platforms without operator support (Supabase/PostgREST). The typed ---! `public.eql_v3_json_search` `@>` operator does NOT call this function — it binds to ---! `eql_v3.jsonb_document_contains` instead — but both agree on the result (a +--! `public.{{prefix}}_json_search` `@>` operator does NOT call this function — it binds to +--! `{{prefix}}.jsonb_document_contains` instead — but both agree on the result (a --! parity test pins this). Also the documented GIN index expression ---! (`eql_v3.jsonb_array(col)`); see docs/reference/database-indexes.md. -CREATE FUNCTION eql_v3.jsonb_contains(a jsonb, b jsonb) +--! (`{{prefix}}.jsonb_array(col)`); see docs/reference/database-indexes.md. +CREATE FUNCTION {{prefix}}.jsonb_contains(a jsonb, b jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE LANGUAGE SQL AS $$ - SELECT eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b); + SELECT {{prefix}}.jsonb_array(a) @> {{prefix}}.jsonb_array(b); $$; -COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_contains(jsonb, jsonb) IS 'eql-inline-critical: raw-jsonb containment helper; must stay inlinable (unpinned search_path)'; --! @brief GIN-indexable "is contained by" check. @@ -282,17 +282,17 @@ COMMENT ON FUNCTION eql_v3.jsonb_contains(jsonb, jsonb) IS --! @return boolean True if all elements of a are contained in b. --! @note Public raw-`jsonb[]` reverse-containment helper — the function-form --! entrypoint for `<@` on platforms without operator support. The typed ---! `public.eql_v3_json_search` `<@` operator binds to `eql_v3.jsonb_document_contains` instead, +--! `public.{{prefix}}_json_search` `<@` operator binds to `{{prefix}}.jsonb_document_contains` instead, --! but both agree on the result. -CREATE FUNCTION eql_v3.jsonb_contained_by(a jsonb, b jsonb) +CREATE FUNCTION {{prefix}}.jsonb_contained_by(a jsonb, b jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE LANGUAGE SQL AS $$ - SELECT eql_v3.jsonb_array(a) <@ eql_v3.jsonb_array(b); + SELECT {{prefix}}.jsonb_array(a) <@ {{prefix}}.jsonb_array(b); $$; -COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_contained_by(jsonb, jsonb) IS 'eql-inline-critical: raw-jsonb contained-by helper; must stay inlinable (unpinned search_path)'; --! @brief Check if an sv array contains a specific sv element. @@ -311,7 +311,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_contained_by(jsonb, jsonb) IS --! @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.jsonb_document_contains(a jsonb[], b jsonb) +CREATE FUNCTION {{prefix}}.jsonb_document_contains(a jsonb[], b jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -324,7 +324,7 @@ AS $$ FOR idx IN 1..array_length(a, 1) LOOP _a := a[idx]; - result := result OR (eql_v3.selector(_a) = eql_v3.selector(b)); + result := result OR ({{prefix}}.selector(_a) = {{prefix}}.selector(b)); EXIT WHEN result; END LOOP; @@ -337,48 +337,48 @@ $$ LANGUAGE plpgsql; --! Empty b is always contained. Each element of b must have its selector --! present in some element of a (selector-subset containment). --! ---! @param a public.eql_v3_json_search Container. ---! @param b public.eql_v3_json_search Elements to find. +--! @param a public.{{prefix}}_json_search Container. +--! @param b public.{{prefix}}_json_search Elements to find. --! @return boolean True if all elements of b are contained in a. ---! @see eql_v3.jsonb_document_contains(jsonb[], jsonb) -CREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search) +--! @see {{prefix}}.jsonb_document_contains(jsonb[], jsonb) +CREATE FUNCTION {{prefix}}.jsonb_document_contains(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb - @> eql_v3.to_ste_vec_query(b)::jsonb + SELECT {{prefix}}.to_ste_vec_query(a)::jsonb + @> {{prefix}}.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). +--! @deprecated Use {{prefix}}.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) +CREATE FUNCTION {{prefix}}.ste_vec_contains(a jsonb[], b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.jsonb_document_contains(a, b) + SELECT {{prefix}}.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)'; +COMMENT ON FUNCTION {{prefix}}.ste_vec_contains(jsonb[], jsonb) IS + 'DEPRECATED: use {{prefix}}.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. +--! @deprecated Use {{prefix}}.jsonb_document_contains(public.{{prefix}}_json_search, public.{{prefix}}_json_search). +--! @param a public.{{prefix}}_json_search Container. +--! @param b public.{{prefix}}_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) +CREATE FUNCTION {{prefix}}.ste_vec_contains(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.jsonb_document_contains(a, b) + SELECT {{prefix}}.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)'; +COMMENT ON FUNCTION {{prefix}}.ste_vec_contains(public.{{prefix}}_json_search, public.{{prefix}}_json_search) IS + 'DEPRECATED: use {{prefix}}.jsonb_document_contains(json_search, json_search)'; --! @endcond ------------------------------------------------------------------------------ @@ -389,30 +389,30 @@ COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eq --! --! Returns one jsonb_entry row per matching encrypted element. Returns empty --! set on no match. It deliberately does not wrap multiple matches as an ---! public.eql_v3_json_search document, because the root document domain requires an `sv` ---! array and single leaves belong to public.eql_v3_json_entry. +--! public.{{prefix}}_json_search document, because the root document domain requires an `sv` +--! array and single leaves belong to public.{{prefix}}_json_entry. --! --! @param val jsonb encrypted EQL payload with `sv`. --! @param selector text Selector hash (`s` value). ---! @return SETOF public.eql_v3_json_entry Matching encrypted entries. ---! @see eql_v3.jsonb_path_query_first -CREATE FUNCTION eql_v3.jsonb_path_query(val jsonb, selector text) - RETURNS SETOF public.eql_v3_json_entry +--! @return SETOF public.{{prefix}}_json_entry Matching encrypted entries. +--! @see {{prefix}}.jsonb_path_query_first +CREATE FUNCTION {{prefix}}.jsonb_path_query(val jsonb, selector text) + RETURNS SETOF public.{{prefix}}_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + SELECT ({{prefix}}.meta_data(val) || elem)::public.{{prefix}}_json_entry FROM jsonb_array_elements(val -> 'sv') elem WHERE elem ->> 's' = selector $$; -COMMENT ON FUNCTION eql_v3.jsonb_path_query(jsonb, text) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_path_query(jsonb, text) IS 'eql-inline-critical: raw-jsonb path query helper; must stay inlinable (unpinned search_path)'; --! @brief Check if a selector path exists in encrypted JSONB. --! @param val jsonb encrypted EQL payload. --! @param selector text Selector hash to test. --! @return boolean True if a matching element exists. -CREATE FUNCTION eql_v3.jsonb_path_exists(val jsonb, selector text) +CREATE FUNCTION {{prefix}}.jsonb_path_exists(val jsonb, selector text) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -422,24 +422,24 @@ AS $$ ); $$; -COMMENT ON FUNCTION eql_v3.jsonb_path_exists(jsonb, text) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_path_exists(jsonb, text) IS 'eql-inline-critical: raw-jsonb path exists helper; must stay inlinable (unpinned search_path)'; --! @brief Get the first sv element matching `selector`, or NULL. --! @param val jsonb encrypted EQL payload. --! @param selector text Selector hash to match. ---! @return public.eql_v3_json_entry First matching element or NULL. -CREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text) - RETURNS public.eql_v3_json_entry +--! @return public.{{prefix}}_json_entry First matching element or NULL. +CREATE FUNCTION {{prefix}}.jsonb_path_query_first(val jsonb, selector text) + RETURNS public.{{prefix}}_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_entry + SELECT ({{prefix}}.meta_data(val) || elem)::public.{{prefix}}_json_entry FROM jsonb_array_elements(val -> 'sv') elem WHERE elem ->> 's' = selector LIMIT 1 $$; -COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS +COMMENT ON FUNCTION {{prefix}}.jsonb_path_query_first(jsonb, text) IS 'eql-inline-critical: raw-jsonb path first helper; must stay inlinable (unpinned search_path)'; ------------------------------------------------------------------------------ @@ -450,7 +450,7 @@ COMMENT ON FUNCTION eql_v3.jsonb_path_query_first(jsonb, text) IS --! @param val jsonb encrypted EQL payload (must have `a` flag true). --! @return integer Number of elements. --! @throws Exception 'cannot get array length of a non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_length(val jsonb) +CREATE FUNCTION {{prefix}}.jsonb_array_length(val jsonb) RETURNS integer IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -458,8 +458,8 @@ AS $$ DECLARE sv jsonb[]; BEGIN - IF eql_v3_internal.is_ste_vec_array(val) THEN - sv := eql_v3.ste_vec(val); + IF {{prefix}}_internal.is_ste_vec_array(val) THEN + sv := {{prefix}}.ste_vec(val); RETURN array_length(sv, 1); END IF; @@ -469,10 +469,10 @@ $$ LANGUAGE plpgsql; --! @brief Extract elements of an encrypted JSONB array as rows. --! @param val jsonb encrypted EQL payload (must have `a` flag true). ---! @return SETOF public.eql_v3_json_entry One row per element (metadata preserved). +--! @return SETOF public.{{prefix}}_json_entry One row per element (metadata preserved). --! @throws Exception 'cannot extract elements from non-array' if not an array. -CREATE FUNCTION eql_v3.jsonb_array_elements(val jsonb) - RETURNS SETOF public.eql_v3_json_entry +CREATE FUNCTION {{prefix}}.jsonb_array_elements(val jsonb) + RETURNS SETOF public.{{prefix}}_json_entry IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -481,25 +481,25 @@ AS $$ meta jsonb; item jsonb; BEGIN - IF NOT eql_v3_internal.is_ste_vec_array(val) THEN + IF NOT {{prefix}}_internal.is_ste_vec_array(val) THEN RAISE 'cannot extract elements from non-array'; END IF; - meta := eql_v3.meta_data(val); - sv := eql_v3.ste_vec(val); + meta := {{prefix}}.meta_data(val); + sv := {{prefix}}.ste_vec(val); FOR idx IN 1..array_length(sv, 1) LOOP item = sv[idx]; - RETURN NEXT (meta || item)::public.eql_v3_json_entry; + RETURN NEXT (meta || item)::public.{{prefix}}_json_entry; END LOOP; RETURN; END; $$ LANGUAGE plpgsql; --- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext +-- NOTE: `{{prefix}}.jsonb_array_elements_text` (SETOF bare per-element ciphertext -- text) was removed with the envelope wire format: an sv entry's `c` is raw -- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext -- stream is not decryptable and the function had no remaining correct use. --- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the +-- Use `{{prefix}}.jsonb_array_elements` — its entry rows carry `s`, `c`, and the -- grafted document key header `h`, the complete decryption unit. diff --git a/packages/eql/src/v3/json/operators.sql b/packages/eql/src/v3/json/operators.sql index eddf1e753..e520f47f3 100644 --- a/packages/eql/src/v3/json/operators.sql +++ b/packages/eql/src/v3/json/operators.sql @@ -5,7 +5,7 @@ -- REQUIRE: src/v3/sem/ope_cllw/types.sql --! @file v3/json/operators.sql ---! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_entry. +--! @brief Operators on public.{{prefix}}_json_search and public.{{prefix}}_json_entry. ------------------------------------------------------------------------------ -- -> field accessor (returns jsonb_entry) @@ -15,67 +15,67 @@ --! --! Returns the sv entry whose `s` equals @p selector, with root `i`/`v` merged --! in. Inlinable: range predicates reduce structurally through ---! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that +--! `{{prefix}}.ord_term(col -> 'sel')` and match a functional btree index on that --! expression. Exact equality is document containment on a value selector. --! --! @warning The selector operand MUST carry a known type — a text-typed --! parameter (`$1`, the Proxy interface) or an explicit cast (`col -> 'sel'::%text`). --! A bare untyped literal (`col -> 'sel'`) resolves to the NATIVE `jsonb -> %text` --! operator and silently returns native jsonb semantics (a root-key lookup, ---! typically NULL), NOT this operator: PostgreSQL reduces the `public.eql_v3_json_search` +--! typically NULL), NOT this operator: PostgreSQL reduces the `public.{{prefix}}_json_search` --! domain to its base type `jsonb` when resolving an unknown-typed RHS, and the --! native base-type operator wins the exact-match tiebreak. This is intrinsic to --! the domain type-kind and applies to the native-jsonb blockers too. See --! the "Typed operands" caveat in docs/reference/json-support.md. --! ---! @param e public.eql_v3_json_search Root encrypted payload. +--! @param e public.{{prefix}}_json_search Root encrypted payload. --! @param selector text Selector hash. ---! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector text) - RETURNS public.eql_v3_json_entry +--! @return public.{{prefix}}_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION {{prefix}}."->"(e public.{{prefix}}_json_search, selector text) + RETURNS public.{{prefix}}_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT ( - eql_v3.meta_data(e) || + {{prefix}}.meta_data(e) || jsonb_path_query_first( e, '$.sv[*] ? (@.s == $sel)'::jsonpath, jsonb_build_object('sel', selector) ) - )::public.eql_v3_json_entry + )::public.{{prefix}}_json_entry $$; CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json_search, + FUNCTION={{prefix}}."->", + LEFTARG=public.{{prefix}}_json_search, RIGHTARG=text ); --! @brief -> operator with integer array index (0-based, JSONB convention). ---! @param e public.eql_v3_json_search Encrypted sv-array payload. +--! @param e public.{{prefix}}_json_search Encrypted sv-array payload. --! @param selector integer Array index. ---! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL. -CREATE FUNCTION eql_v3."->"(e public.eql_v3_json_search, selector integer) - RETURNS public.eql_v3_json_entry +--! @return public.{{prefix}}_json_entry Matching entry merged with root meta, or NULL. +CREATE FUNCTION {{prefix}}."->"(e public.{{prefix}}_json_search, selector integer) + RETURNS public.{{prefix}}_json_entry LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE - WHEN eql_v3_internal.is_ste_vec_array(e) THEN + WHEN {{prefix}}_internal.is_ste_vec_array(e) THEN -- NOTE: `e::jsonb` makes the native-jsonb traversal explicit. `'sv'` is an - -- unknown-typed literal, so `e -> 'sv'` already flattens `public.eql_v3_json_search` to + -- unknown-typed literal, so `e -> 'sv'` already flattens `public.{{prefix}}_json_search` to -- its base type and binds native `jsonb -> text` (see the @warning above) — - -- the custom `->(public.eql_v3_json_search, text)` operator does NOT capture a bare + -- the custom `->(public.{{prefix}}_json_search, text)` operator does NOT capture a bare -- untyped literal. The cast documents that intent and guards the `-> selector` - -- (integer) hop from ever resolving to the v3 `->(public.eql_v3_json_search, integer)` + -- (integer) hop from ever resolving to the v3 `->(public.{{prefix}}_json_search, integer)` -- operator instead of native array access. - (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry + ({{prefix}}.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.{{prefix}}_json_entry ELSE NULL END $$; CREATE OPERATOR ->( - FUNCTION=eql_v3."->", - LEFTARG=public.eql_v3_json_search, + FUNCTION={{prefix}}."->", + LEFTARG=public.{{prefix}}_json_search, RIGHTARG=integer ); @@ -89,37 +89,37 @@ CREATE OPERATOR ->( --! Intentional v2 parity: this serializes the entire matched jsonb_entry --! object as JSON text. It does not decrypt or return scalar plaintext like --! native `jsonb ->>`. ---! @param e public.eql_v3_json_search Encrypted payload. +--! @param e public.{{prefix}}_json_search Encrypted payload. --! @param selector text Field selector hash. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector text) +CREATE FUNCTION {{prefix}}."->>"(e public.{{prefix}}_json_search, selector text) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text + SELECT {{prefix}}."->"(e, selector)::jsonb::text $$; CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json_search, + FUNCTION={{prefix}}."->>", + LEFTARG=public.{{prefix}}_json_search, RIGHTARG=text ); --! @brief ->> operator with integer array index. Inlinable alias of --! ->(json, integer) coerced to text. ---! @param e public.eql_v3_json_search Encrypted sv-array payload. +--! @param e public.{{prefix}}_json_search Encrypted sv-array payload. --! @param selector integer Array index. --! @return text The matching entry as text. -CREATE FUNCTION eql_v3."->>"(e public.eql_v3_json_search, selector integer) +CREATE FUNCTION {{prefix}}."->>"(e public.{{prefix}}_json_search, selector integer) RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3."->"(e, selector)::jsonb::text + SELECT {{prefix}}."->"(e, selector)::jsonb::text $$; CREATE OPERATOR ->> ( - FUNCTION=eql_v3."->>", - LEFTARG=public.eql_v3_json_search, + FUNCTION={{prefix}}."->>", + LEFTARG=public.{{prefix}}_json_search, RIGHTARG=integer ); @@ -128,43 +128,43 @@ CREATE OPERATOR ->> ( ------------------------------------------------------------------------------ --! @brief @> contains operator (document, document). ---! @param a public.eql_v3_json_search Container. ---! @param b public.eql_v3_json_search Contained value. +--! @param a public.{{prefix}}_json_search Container. +--! @param b public.{{prefix}}_json_search Contained value. --! @return boolean True if a contains b. ---! @see eql_v3.jsonb_document_contains -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b public.eql_v3_json_search) +--! @see {{prefix}}.jsonb_document_contains +CREATE FUNCTION {{prefix}}."@>"(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.jsonb_document_contains(a, b) + SELECT {{prefix}}.jsonb_document_contains(a, b) $$; CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json_search, - RIGHTARG=public.eql_v3_json_search + FUNCTION={{prefix}}."@>", + LEFTARG=public.{{prefix}}_json_search, + RIGHTARG=public.{{prefix}}_json_search ); --! @brief @> contains operator with an query_json needle. --! ---! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a +--! Inlines to native `jsonb @>` over `{{prefix}}.to_ste_vec_query(a)::jsonb`, so a --! functional GIN index on the same expression engages. --! ---! @param a public.eql_v3_json_search Container. ---! @param b eql_v3.query_json Query payload. +--! @param a public.{{prefix}}_json_search Container. +--! @param b {{prefix}}.query_json Query payload. --! @return boolean True if a contains b. -CREATE FUNCTION eql_v3."@>"(a public.eql_v3_json_search, b eql_v3.query_json) +CREATE FUNCTION {{prefix}}."@>"(a public.{{prefix}}_json_search, b {{prefix}}.query_json) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.to_ste_vec_query(a)::jsonb - @> eql_v3.to_ste_vec_query(b)::jsonb + SELECT {{prefix}}.to_ste_vec_query(a)::jsonb + @> {{prefix}}.to_ste_vec_query(b)::jsonb $$; CREATE OPERATOR @>( - FUNCTION=eql_v3."@>", - LEFTARG=public.eql_v3_json_search, - RIGHTARG=eql_v3.query_json + FUNCTION={{prefix}}."@>", + LEFTARG=public.{{prefix}}_json_search, + RIGHTARG={{prefix}}.query_json ); -- NOTE: there is deliberately NO computable `@>`(json_search, json_entry) @@ -173,7 +173,7 @@ CREATE OPERATOR @>( -- ({s,c,op?}) and carries no value selector, so it can only ever match -- structurally ("the document has a node at this path") — value-blind for -- bool/null/object/array and op-lossy for number/string. Exact field equality is --- document containment on the value selector: `col @> $1::eql_v3.query_json`, +-- document containment on the value selector: `col @> $1::{{prefix}}.query_json`, -- where a value-selector's presence in the stored document IS the exact match. -- Routing all value equality through that one exact mechanism is why the -- structural single-entry behavior (and its `<@` reverse) was blocked. @@ -183,38 +183,38 @@ CREATE OPERATOR @>( ------------------------------------------------------------------------------ --! @brief <@ contained-by operator (document, document). ---! @param a public.eql_v3_json_search Contained value. ---! @param b public.eql_v3_json_search Container. +--! @param a public.{{prefix}}_json_search Contained value. +--! @param b public.{{prefix}}_json_search Container. --! @return boolean True if a is contained by b. -CREATE FUNCTION eql_v3."<@"(a public.eql_v3_json_search, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}."<@"(a public.{{prefix}}_json_search, b public.{{prefix}}_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.to_ste_vec_query(b)::jsonb - @> eql_v3.to_ste_vec_query(a)::jsonb + SELECT {{prefix}}.to_ste_vec_query(b)::jsonb + @> {{prefix}}.to_ste_vec_query(a)::jsonb $$; CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=public.eql_v3_json_search, - RIGHTARG=public.eql_v3_json_search + FUNCTION={{prefix}}."<@", + LEFTARG=public.{{prefix}}_json_search, + RIGHTARG=public.{{prefix}}_json_search ); --! @brief <@ contained-by operator with an query_json LHS. ---! @param a eql_v3.query_json Query payload. ---! @param b public.eql_v3_json_search Container. +--! @param a {{prefix}}.query_json Query payload. +--! @param b public.{{prefix}}_json_search Container. --! @return boolean True if b contains a. -CREATE FUNCTION eql_v3."<@"(a eql_v3.query_json, b public.eql_v3_json_search) +CREATE FUNCTION {{prefix}}."<@"(a {{prefix}}.query_json, b public.{{prefix}}_json_search) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3."@>"(b, a) + SELECT {{prefix}}."@>"(b, a) $$; CREATE OPERATOR <@( - FUNCTION=eql_v3."<@", - LEFTARG=eql_v3.query_json, - RIGHTARG=public.eql_v3_json_search + FUNCTION={{prefix}}."<@", + LEFTARG={{prefix}}.query_json, + RIGHTARG=public.{{prefix}}_json_search ); -- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is @@ -230,60 +230,60 @@ CREATE OPERATOR <@( --! `bigint`/`numeric`/`text`; exact equality is document containment on a --! value-selector needle. This blocker is deliberately non-STRICT so a --! NULL operand cannot bypass the error. ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '='); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '='); END; $$ LANGUAGE plpgsql; CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry ); --! @brief Block inequality between two extracted jsonb entries. ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean Never returns; always raises 'operator not supported'. -CREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>'); + RETURN {{prefix}}_internal.encrypted_domain_unsupported_bool('public.{{prefix}}_json_entry', '<>'); END; $$ LANGUAGE plpgsql; CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry ); --! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order). ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean True if a is less than b -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) + SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, @@ -291,20 +291,20 @@ CREATE OPERATOR < ( ); --! @brief Less-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean True if a is less than or equal to b -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) + SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, @@ -312,20 +312,20 @@ CREATE OPERATOR <= ( ); --! @brief Greater-than on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean True if a is greater than b -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) + SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, @@ -333,20 +333,20 @@ CREATE OPERATOR > ( ); --! @brief Greater-than-or-equal on jsonb_entry via the CLLW OPE term. ---! @param a public.eql_v3_json_entry Left operand ---! @param b public.eql_v3_json_entry Right operand +--! @param a public.{{prefix}}_json_entry Left operand +--! @param b public.{{prefix}}_json_entry Right operand --! @return boolean True if a is greater than or equal to b -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) + SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, - RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, + RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, diff --git a/packages/eql/src/v3/json/types.sql b/packages/eql/src/v3/json/types.sql index 0bc34904b..ae4868ccf 100644 --- a/packages/eql/src/v3/json/types.sql +++ b/packages/eql/src/v3/json/types.sql @@ -1,14 +1,14 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/json/types.sql ---! @brief Domain types for the eql_v3 encrypted-JSONB (SteVec) surface. +--! @brief Domain types for the {{prefix}} encrypted-JSONB (SteVec) surface. --! --! Three jsonb-backed domains (none over another domain — operators resolve --! against the ultimate base type jsonb, so the native-jsonb firewall in --! blockers.sql can attach): ---! - public.eql_v3_json_search — storage/root: an EQL envelope object ({i, v, ...}). ---! - public.eql_v3_json_entry — a single sv element (returned by `->`). ---! - eql_v3.query_json — a containment needle (sv elements, no ciphertext). +--! - public.{{prefix}}_json_search — storage/root: an EQL envelope object ({i, v, ...}). +--! - public.{{prefix}}_json_entry — a single sv element (returned by `->`). +--! - {{prefix}}.query_json — a containment needle (sv elements, no ciphertext). --! @brief Validate a single SteVec entry payload. --! @internal @@ -22,8 +22,8 @@ --! a stale `hm`-bearing payload fails loudly rather than degrading to --! a value-less entry. The optional document metadata `i`, `v`, and --! `h` is accepted because selector lookup grafts it onto the entry ---! before casting to `public.eql_v3_json_entry`. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_entry_payload(val jsonb) +--! before casting to `public.{{prefix}}_json_entry`. +CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_entry_payload(val jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -48,12 +48,12 @@ $$; --! set of selectors — a value-selector's presence in the stored --! document IS the exact value match. --! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the ---! eql_v3.query_json domain CHECK, where a SQL function can never be +--! {{prefix}}.query_json domain CHECK, where a SQL function can never be --! inlined (and the CHECK itself cannot absorb this body — it needs a --! subquery over the sv elements, which CHECK constraints forbid). plpgsql --! caches its plan across calls instead of paying the per-call SQL-function --! executor on every needle cast. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_query_payload(val jsonb) +CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_query_payload(val jsonb) RETURNS boolean LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -92,14 +92,14 @@ $$; --! derived from the entries' selectors) — it is opaque to SQL and --! only ever carried/grafted, never parsed. Unknown envelope keys are --! rejected; `k` and `a` remain optional compatibility fields. -CREATE OR REPLACE FUNCTION public.eql_v3_is_valid_ste_vec_document_payload(val jsonb) +CREATE OR REPLACE FUNCTION public.{{prefix}}_is_valid_ste_vec_document_payload(val jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT COALESCE( jsonb_typeof(val) = 'object' AND val ? 'v' - AND val ->> 'v' = '3' + AND val ->> 'v' = '{{eql_version}}' AND val ? 'i' AND jsonb_typeof(val -> 'h') = 'string' AND jsonb_typeof(val -> 'sv') = 'array' @@ -109,7 +109,7 @@ AS $$ FROM jsonb_array_elements( CASE WHEN jsonb_typeof(val -> 'sv') = 'array' THEN val -> 'sv' ELSE '[]'::jsonb END ) AS elem - WHERE NOT public.eql_v3_is_valid_ste_vec_entry_payload(elem) + WHERE NOT public.{{prefix}}_is_valid_ste_vec_entry_payload(elem) ), false ) @@ -123,26 +123,26 @@ $$; --! root document ciphertext lives on the root sv entry). The CHECK also --! requires an `sv` array, so the domain accepts only SteVec **document** --! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob` ---! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed +--! but no `sv`) — this is what keeps `public.{{prefix}}_json_search` a typed --! document domain rather than a generic encrypted envelope. The firewall in --! blockers.sql attaches to this domain to stop native jsonb operators from --! reaching a column value. --! --! @note Constructing from inline JSON uses the standard DOMAIN cast: ---! `'{"i":{},"v":3,"h":"...","sv":[...]}'::public.eql_v3_json_search`. +--! `'{"i":{},"v":{{eql_version}},"h":"...","sv":[...]}'::public.{{prefix}}_json_search`. DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_json_search' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_json_search AS jsonb + CREATE DOMAIN public.{{prefix}}_json_search AS jsonb CHECK ( - public.eql_v3_is_valid_ste_vec_document_payload(VALUE) + public.{{prefix}}_is_valid_ste_vec_document_payload(VALUE) ); END IF; - COMMENT ON DOMAIN public.eql_v3_json_search IS 'EQL encrypted JSONB searchable document (containment)'; + COMMENT ON DOMAIN public.{{prefix}}_json_search IS 'EQL encrypted JSONB searchable document (containment)'; END $$; @@ -154,8 +154,8 @@ $$; --! (value-inclusive selectors) and non-orderable path entries are term-less --! `{s, c}`: exact matching is selector presence, so there is no per-value --! equality term (`hm` is retired and rejected). This is the type returned by ---! `->` and accepted by the per-entry extractors `eql_v3.ope_term` / ---! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases +--! `->` and accepted by the per-entry extractors `{{prefix}}.ope_term` / +--! `{{prefix}}.ord_term`. The deprecated `eq_term(json_entry)` name aliases --! `ope_term`. The optional array marker `a` and root `i`/`v`/`h` --! metadata merged in by `->` are the only additional fields accepted. --! @@ -163,7 +163,7 @@ $$; --! --! @internal --! Implementation note (issue #354): the CHECK is an INLINE expression, not a ---! call to `public.eql_v3_is_valid_ste_vec_entry_payload` — domain +--! call to `public.{{prefix}}_is_valid_ste_vec_entry_payload` — domain --! constraints cannot inline SQL functions, so the function-call form paid --! the per-call SQL-function executor (~18 µs) on EVERY cast: the needle --! cast in every field_eq query (+19% end-to-end vs v2, the entire measured @@ -178,9 +178,9 @@ DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json_entry' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_json_entry' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_json_entry AS jsonb + CREATE DOMAIN public.{{prefix}}_json_entry AS jsonb CHECK ( VALUE IS NULL OR COALESCE( @@ -196,7 +196,7 @@ BEGIN ); END IF; - COMMENT ON DOMAIN public.eql_v3_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_json_entry IS 'EQL encrypted JSONB leaf entry (equality, ordering)'; END $$; @@ -210,36 +210,36 @@ $$; --! casting and matching every row via bare `jsonb @>`. --! --! @note Construct from inline JSON via the DOMAIN cast: ---! `'{"sv":[{"s":""}]}'::eql_v3.query_json`. ---! @see eql_v3.to_ste_vec_query +--! `'{"sv":[{"s":""}]}'::{{prefix}}.query_json`. +--! @see {{prefix}}.to_ste_vec_query --! --! @internal --! Implementation note (issue #354): this CHECK CANNOT be inlined like ---! public.eql_v3_json_entry's — validating the sv elements requires a subquery +--! public.{{prefix}}_json_entry's — validating the sv elements requires a subquery --! (`NOT EXISTS (SELECT ... FROM jsonb_array_elements(...))`), and CHECK --! constraints forbid subqueries. The validator is plpgsql instead (cached --! plan; substantially cheaper per call than a non-inlined LANGUAGE sql --! function — the same finding as issue #353), since this cast sits on the --! per-query hot path of every containment scenario ---! (`$1::jsonb::eql_v3.query_json`). +--! (`$1::jsonb::{{prefix}}.query_json`). --! @endinternal DO $$ BEGIN IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_json' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_json AS jsonb + CREATE DOMAIN {{prefix}}.query_json AS jsonb CHECK ( - public.eql_v3_is_valid_ste_vec_query_payload(VALUE) + public.{{prefix}}_is_valid_ste_vec_query_payload(VALUE) ); END IF; - COMMENT ON DOMAIN eql_v3.query_json IS 'EQL JSONB query operand (containment)'; + COMMENT ON DOMAIN {{prefix}}.query_json IS 'EQL JSONB query operand (containment)'; END $$; ---! @brief Convert a public.eql_v3_json_search to a query_json needle. +--! @brief Convert a public.{{prefix}}_json_search to a query_json needle. --! --! Normalises each sv element down to its selector `s`. Exact and structural --! containment are both selector-set containment; an `op` carried by a legacy @@ -247,13 +247,13 @@ $$; --! but is not part of the containment predicate. Other fields are stripped. --! This is the canonical needle shape for `@>` containment and the functional --! GIN index expression: ---! `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. +--! `GIN ({{prefix}}.to_ste_vec_query(col)::jsonb jsonb_path_ops)`. --! ---! @param e public.eql_v3_json_search Source encrypted payload ---! @return eql_v3.query_json Query-shaped needle, sv elements normalised. ---! @see eql_v3.query_json -CREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search) - RETURNS eql_v3.query_json +--! @param e public.{{prefix}}_json_search Source encrypted payload +--! @return {{prefix}}.query_json Query-shaped needle, sv elements normalised. +--! @see {{prefix}}.query_json +CREATE FUNCTION {{prefix}}.to_ste_vec_query(e public.{{prefix}}_json_search) + RETURNS {{prefix}}.query_json LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT jsonb_build_object( @@ -269,7 +269,7 @@ AS $$ FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), '[]'::jsonb ) - )::eql_v3.query_json + )::{{prefix}}.query_json $$; --! @brief Normalise an already query-shaped needle to selector-only form. @@ -278,8 +278,8 @@ $$; --! therefore carry the path entry's `op`. Containment is selector-set --! containment, so this overload strips `op` before comparison and keeps every --! public containment entry point semantically identical. -CREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json) - RETURNS eql_v3.query_json +CREATE FUNCTION {{prefix}}.to_ste_vec_query(e {{prefix}}.query_json) + RETURNS {{prefix}}.query_json LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT jsonb_build_object( @@ -289,9 +289,9 @@ AS $$ FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem), '[]'::jsonb ) - )::eql_v3.query_json + )::{{prefix}}.query_json $$; -CREATE CAST (public.eql_v3_json_search AS eql_v3.query_json) - WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search) +CREATE CAST (public.{{prefix}}_json_search AS {{prefix}}.query_json) + WITH FUNCTION {{prefix}}.to_ste_vec_query(public.{{prefix}}_json_search) AS ASSIGNMENT; diff --git a/packages/eql/src/v3/lint/lints.sql b/packages/eql/src/v3/lint/lints.sql index 69878bf80..c68307f0c 100644 --- a/packages/eql/src/v3/lint/lints.sql +++ b/packages/eql/src/v3/lint/lints.sql @@ -2,7 +2,7 @@ --! @brief EQL lint: detect non-inlinable operator implementation functions --! ---! Returns one row per violation found in the installed `eql_v3` surface. The +--! Returns one row per violation found in the installed `{{prefix}}` surface. The --! Postgres planner can only inline a function during index matching when: --! --! * `LANGUAGE sql` (plpgsql / C / etc. cannot be inlined) @@ -18,11 +18,11 @@ --! remaining non-inlinable. Implementing the check requires walking `prosrc` --! (or `pg_get_functiondef`); tracked as a follow-up. --! ---! Operators on `eql_v3` types (the jsonb-backed encrypted-domain families and ---! the SEM index-term type `eql_v3_internal.ore_block_256`) whose +--! Operators on `{{prefix}}` types (the jsonb-backed encrypted-domain families and +--! the SEM index-term type `{{prefix}}_internal.ore_block_256`) whose --! implementation functions fail any of these rules silently fall back to seq ---! scan when the documented functional indexes (`eql_v3.eq_term(col)`, ---! `eql_v3.ord_term(col)`) are in place. This lint surfaces every such case. +--! scan when the documented functional indexes (`{{prefix}}.eq_term(col)`, +--! `{{prefix}}.ord_term(col)`) are in place. This lint surfaces every such case. --! --! Severity: --! `error` — fixable, blocks index matching, ship-blocking. @@ -47,32 +47,32 @@ --! PostgreSQL skips the body and returns NULL --! on NULL arguments, silently bypassing the --! RAISE. ---! `domain_over_domain` — an `eql_v3` encrypted domain is derived from +--! `domain_over_domain` — an `{{prefix}}` encrypted domain is derived from --! another encrypted domain rather than jsonb. --! Operators resolve against the ultimate base --! type, so the derived domain does not --! inherit the base domain's blocker surface. --! `domain_opclass` — an operator class is declared FOR TYPE on an ---! `eql_v3` encrypted domain. Opclasses on +--! `{{prefix}}` encrypted domain. Opclasses on --! domains bypass operator resolution; use a --! functional index on the extractor instead. --! `schema_placement` — a naked composite or enum TYPE lives in the ---! public `eql_v3` schema. Internal index-term +--! public `{{prefix}}` schema. Internal index-term --! types (e.g. `ore_block_256_term`) belong in ---! `eql_v3_internal`; a composite/enum in ---! `eql_v3` clutters the Supabase Table Builder +--! `{{prefix}}_internal`; a composite/enum in +--! `{{prefix}}` clutters the Supabase Table Builder --! type picker, which the schema split exists to ---! prevent. Move it to `eql_v3_internal`. +--! prevent. Move it to `{{prefix}}_internal`. --! --! @code{.sql} --! SELECT severity, category, object_name, message ---! FROM eql_v3.lints() +--! FROM {{prefix}}.lints() --! WHERE severity = 'error' --! ORDER BY category, object_name; --! @endcode --! --! @return SETOF record (severity text, category text, object_name text, message text) -CREATE OR REPLACE FUNCTION eql_v3.lints() +CREATE OR REPLACE FUNCTION {{prefix}}.lints() RETURNS TABLE ( severity text, category text, @@ -98,7 +98,7 @@ AS $$ AND bn.nspname = 'pg_catalog' AND ( dn.nspname = 'public' - OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + OR dn.nspname = ANY({{prefix}}_internal.owned_schemas()) ) ), @@ -118,7 +118,7 @@ AS $$ SELECT 1 FROM pg_type t WHERE t.oid IN (op.oprleft, op.oprright) AND ( - t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY(eql_v3_internal.owned_schemas())) + t.typnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY({{prefix}}_internal.owned_schemas())) OR t.oid IN (SELECT typid FROM encrypted_domain_types) ) ) @@ -143,7 +143,7 @@ AS $$ JOIN pg_language lang_l ON lang_l.oid = p.prolang ), - -- Encrypted-domain blockers: functions in `eql_v3` whose body contains + -- Encrypted-domain blockers: functions in `{{prefix}}` whose body contains -- a blocker marker emitted by the codegen (any of the -- `encrypted_domain_unsupported_*` helper calls — `_bool` for boolean -- blockers, `_jsonb` for the native-jsonb-operator blockers; plus the @@ -161,7 +161,7 @@ AS $$ FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace JOIN pg_catalog.pg_language lang_l ON lang_l.oid = p.prolang - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas()) AND (p.prosrc LIKE '%encrypted_domain_unsupported%' OR p.prosrc LIKE '%is not supported for%') AND EXISTS ( @@ -343,7 +343,7 @@ AS $$ JOIN pg_catalog.pg_type bt ON bt.oid = dt.typbasetype JOIN pg_catalog.pg_namespace bn ON bn.oid = bt.typnamespace WHERE dt.typtype = 'd' - AND dn.nspname = ANY(eql_v3_internal.owned_schemas()) + AND dn.nspname = ANY({{prefix}}_internal.owned_schemas()) AND bt.typtype = 'd' AND bt.oid IN (SELECT typid FROM encrypted_domain_types) @@ -369,7 +369,7 @@ AS $$ WHERE t.oid IN (SELECT typid FROM encrypted_domain_types) -- ┌─────────────────────────────────────────────────────────────────┐ - -- │ Schema placement: the public `eql_v3` schema must hold only the │ + -- │ Schema placement: the public `{{prefix}}` schema must hold only the │ -- │ jsonb-backed encrypted-domain types. A naked composite/enum type │ -- │ there is an internal index-term type in the wrong schema — it │ -- │ clutters the Supabase type picker the split exists to keep clean. │ @@ -382,19 +382,19 @@ AS $$ 'schema_placement', format('type %I.%I', n.nspname, t.typname), format( - 'Type `%s.%s` is a %s in the public `eql_v3` schema. Only jsonb-backed encrypted-domain types belong in `eql_v3`; internal index-term types belong in `eql_v3_internal` so they stay out of the Supabase Table Builder type picker. Move it to `eql_v3_internal`.', + 'Type `%s.%s` is a %s in the public `{{prefix}}` schema. Only jsonb-backed encrypted-domain types belong in `{{prefix}}`; internal index-term types belong in `{{prefix}}_internal` so they stay out of the Supabase Table Builder type picker. Move it to `{{prefix}}_internal`.', n.nspname, t.typname, CASE t.typtype WHEN 'c' THEN 'composite type' WHEN 'e' THEN 'enum type' ELSE 'type' END) FROM pg_catalog.pg_type t JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace - WHERE n.nspname = 'eql_v3' + WHERE n.nspname = '{{prefix}}' AND t.typtype IN ('c', 'e') ORDER BY 1, 2, 3; $$; -COMMENT ON FUNCTION eql_v3.lints() IS +COMMENT ON FUNCTION {{prefix}}.lints() IS 'EQL lint: returns one row per non-inlinable operator implementation. ' - 'Run `SELECT * FROM eql_v3.lints() WHERE severity = ''error''` for a ' - 'CI-gateable check that all operator implementations on eql_v3 types are ' + 'Run `SELECT * FROM {{prefix}}.lints() WHERE severity = ''error''` for a ' + 'CI-gateable check that all operator implementations on {{prefix}} types are ' 'eligible for planner inlining.'; diff --git a/packages/eql/src/v3/scalars/functions.sql b/packages/eql/src/v3/scalars/functions.sql index 3d6b7b3da..1376a4719 100644 --- a/packages/eql/src/v3/scalars/functions.sql +++ b/packages/eql/src/v3/scalars/functions.sql @@ -1,7 +1,7 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/scalars/functions.sql ---! @brief Shared blocker helper for the eql_v3 encrypted-domain families. +--! @brief Shared blocker helper for the {{prefix}} encrypted-domain families. --! --! Per-domain wrapper functions live in src/v3/scalars//. --! Blockers in those files delegate to encrypted_domain_unsupported_bool @@ -12,10 +12,10 @@ --! @brief Shared blocker helper. Raises 'operator X is not supported --! for TYPE' so unsupported domain operators surface a clear --! error rather than fall through to native jsonb behaviour. ---! @param type_name Domain type name (eql_v3.*) +--! @param type_name Domain type name ({{prefix}}.*) --! @param operator_name Operator symbol (=, <, @>, ->, etc.) --! @return boolean (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) +CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_bool(type_name text, operator_name text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -30,10 +30,10 @@ $$ LANGUAGE plpgsql; --! native operators whose result is jsonb (#>, -, #-, ||), so composed --! expressions resolve and the body raises rather than failing earlier --! with a misleading 'operator does not exist' on a boolean result. ---! @param type_name Domain type name (eql_v3.*) +--! @param type_name Domain type name ({{prefix}}.*) --! @param operator_name Operator symbol (#>, -, #-, ||, etc.) --! @return jsonb (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) +CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_jsonb(type_name text, operator_name text) RETURNS jsonb IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -46,10 +46,10 @@ $$ LANGUAGE plpgsql; --! @brief Shared blocker helper returning text. Identical to --! encrypted_domain_unsupported_bool but typed for blockers shadowing --! the native #>> operator whose result is text. ---! @param type_name Domain type name (eql_v3.*) +--! @param type_name Domain type name ({{prefix}}.*) --! @param operator_name Operator symbol (#>>) --! @return text (never returns; always raises) -CREATE FUNCTION eql_v3_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) +CREATE FUNCTION {{prefix}}_internal.encrypted_domain_unsupported_text(type_name text, operator_name text) RETURNS text IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public diff --git a/packages/eql/src/v3/schema.sql b/packages/eql/src/v3/schema.sql index 4411f8e9b..9149f93d7 100644 --- a/packages/eql/src/v3/schema.sql +++ b/packages/eql/src/v3/schema.sql @@ -1,18 +1,18 @@ --! @file v3/schema.sql --! @brief EQL v3 schema creation --! ---! Creates the eql_v3 and eql_v3_internal schemas. User-column encrypted ---! domains (public.eql_v3_integer, public.eql_v3_bigint, and future scalar domains) live in ---! public so application tables survive EQL schema uninstall. eql_v3 is the +--! Creates the {{prefix}} and {{prefix}}_internal schemas. User-column encrypted +--! domains (public.{{prefix}}_integer, public.{{prefix}}_bigint, and future scalar domains) live in +--! public so application tables survive EQL schema uninstall. {{prefix}} is the --! public API for index-term extractors, aggregates, AND the operator-backing --! comparison wrappers --! (eq/neq/lt/lte/gt/gte/contains/contained_by, plus the jsonb containment --! helpers). The wrappers are public because they are the function-form --! equivalent of every supported operator: platforms without operator support --! (Supabase/PostgREST calls functions, not operators) invoke them by name. ---! eql_v3_internal houses INTERNAL implementation objects only: the +--! {{prefix}}_internal houses INTERNAL implementation objects only: the --! searchable-encrypted-metadata (SEM) index-term types ---! (eql_v3_internal.hmac_256, eql_v3_internal.ore_block_256) and their support +--! ({{prefix}}_internal.hmac_256, {{prefix}}_internal.ore_block_256) and their support --! functions, the unsupported-operator blockers (which only raise), and the --! aggregate state functions. Together the two schemas are self-contained — --! they own every type they need and have no runtime dependency on another EQL @@ -21,58 +21,58 @@ --! Drops existing schema if present to support clean reinstallation. --! --! @warning DROP SCHEMA CASCADE will remove all objects in the schema ---! @note eql_v3 is a new, additional schema for the encrypted-domain families. +--! @note {{prefix}} is a new, additional schema for the encrypted-domain families. --! --! @note DESIGN DECISION — EQL never grants permissions automatically. This ---! installer issues no GRANT (or REVOKE) on eql_v3 or eql_v3_internal: +--! installer issues no GRANT (or REVOKE) on {{prefix}} or {{prefix}}_internal: --! access is strictly opt-in. A deployment that exposes EQL to --! non-owner roles (e.g. Supabase `authenticated`/`anon` via PostgREST) ---! must explicitly `GRANT USAGE ON SCHEMA eql_v3` and `GRANT EXECUTE` on +--! must explicitly `GRANT USAGE ON SCHEMA {{prefix}}` and `GRANT EXECUTE` on --! the functions it needs. This is intentional least-privilege, not an ---! oversight — see docs/reference/permissions.md. eql_v3_internal is not +--! oversight — see docs/reference/permissions.md. {{prefix}}_internal is not --! part of the public API and normally needs no grant; where a caller --! reaches an internal object indirectly (a public operator/aggregate --! whose backing state-fn/blocker lives there), grant it deliberately. --! @brief Drop existing EQL v3 schema --! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3 CASCADE; +DROP SCHEMA IF EXISTS {{prefix}} CASCADE; --! @brief Create EQL v3 schema --! @note Houses the encrypted-domain type families -CREATE SCHEMA eql_v3; +CREATE SCHEMA {{prefix}}; --! @brief Drop existing EQL v3 internal schema --! @warning CASCADE will drop all dependent objects -DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; +DROP SCHEMA IF EXISTS {{prefix}}_internal CASCADE; --! @brief Create EQL v3 internal implementation schema ---! @note Houses INTERNAL eql_v3 objects only: SEM index-term TYPES + their +--! @note Houses INTERNAL {{prefix}} objects only: SEM index-term TYPES + their --! support/constructor/comparator functions, the unsupported-operator --! blockers (which only raise), the aggregate state functions, and the ---! SteVec CHECK validators. Kept out of the public `eql_v3` surface so +--! SteVec CHECK validators. Kept out of the public `{{prefix}}` surface so --! internal index-term TYPES do not clutter the Supabase Table Builder --! type picker. NOTE: the operator-backing comparison *wrappers* are NOT ---! here — they are public in `eql_v3` so every operator has a callable +--! here — they are public in `{{prefix}}` so every operator has a callable --! function equivalent for platforms without operator support. -CREATE SCHEMA eql_v3_internal; -COMMENT ON SCHEMA eql_v3_internal IS +CREATE SCHEMA {{prefix}}_internal; +COMMENT ON SCHEMA {{prefix}}_internal IS 'EQL internal implementation detail; not a public API surface.'; ---! @brief Schemas owned by the eql_v3 surface +--! @brief Schemas owned by the {{prefix}} surface --! --! Single source of truth for tooling that must enumerate every schema this ---! installer owns (`eql_v3.lints()`, `tasks/pin_search_path_v3.sql`), so a ---! future third eql_v3-family schema is one array literal to edit instead of +--! installer owns (`{{prefix}}.lints()`, `tasks/pin_search_path_v3.sql`), so a +--! future third {{prefix}}-family schema is one array literal to edit instead of --! a hardcoded schema-name predicate repeated at every call site. Keep in --! sync with the `SCHEMA` / `INTERNAL_SCHEMA` constants in --! `crates/eql-codegen/src/consts.rs` — those drive what codegen emits into --! each schema; this drives what tooling scans across both. --! ---! @return name[] The schema names eql_v3 owns (public + internal). -CREATE FUNCTION eql_v3_internal.owned_schemas() +--! @return name[] The schema names {{prefix}} owns (public + internal). +CREATE FUNCTION {{prefix}}_internal.owned_schemas() RETURNS name[] LANGUAGE sql IMMUTABLE PARALLEL SAFE AS $$ - SELECT ARRAY['eql_v3', 'eql_v3_internal']::name[] + SELECT ARRAY['{{prefix}}', '{{prefix}}_internal']::name[] $$; diff --git a/packages/eql/src/v3/sem/bloom_filter/functions.sql b/packages/eql/src/v3/sem/bloom_filter/functions.sql index bcee55da4..db4db5202 100644 --- a/packages/eql/src/v3/sem/bloom_filter/functions.sql +++ b/packages/eql/src/v3/sem/bloom_filter/functions.sql @@ -2,10 +2,10 @@ -- REQUIRE: src/v3/sem/bloom_filter/types.sql --! @file v3/sem/bloom_filter/functions.sql ---! @brief Extractor for the eql_v3 Bloom-filter SEM index term. +--! @brief Extractor for the {{prefix}} Bloom-filter SEM index term. --! --! jsonb-only subset of src/bloom_filter/functions.sql. The encrypted-column ---! overloads are intentionally omitted — the eql_v3 scalar domains extract from +--! overloads are intentionally omitted — the {{prefix}} scalar domains extract from --! the jsonb payload directly via a cast to the domain. (Doc comments --! deliberately avoid naming eql_v2 symbols so the self-containment grep stays --! clean.) @@ -15,12 +15,12 @@ --! @param val jsonb The encrypted payload. --! @return boolean True when the `bf` key is present and non-null. --! ---! @internal Defined for parity with the eql_v3 SEM index-term predicates +--! @internal Defined for parity with the {{prefix}} SEM index-term predicates --! (`has_hmac_256` / `has_ore_block_256`); it is not currently called by --! the extractor below, which gates on value-shape inline, nor by the generated --! domain CHECK, which tests `bf` presence via the envelope-key skeleton. Kept --! as the canonical presence test for callers that need one. -CREATE FUNCTION eql_v3_internal.has_bloom_filter(val jsonb) +CREATE FUNCTION {{prefix}}_internal.has_bloom_filter(val jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -33,8 +33,8 @@ $$ LANGUAGE plpgsql; --! @brief Extract the Bloom-filter index term from a jsonb payload. --! --! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so the functional GIN index built on `eql_v3_internal.match_term(col)` (which ---! calls this) engages structurally. Mirrors `eql_v3_internal.hmac_256(jsonb)`: no RAISE +--! query so the functional GIN index built on `{{prefix}}_internal.match_term(col)` (which +--! calls this) engages structurally. Mirrors `{{prefix}}_internal.hmac_256(jsonb)`: no RAISE --! and no pinned `search_path`. Returns NULL when `bf` is absent or present but --! not a json array, rather than raising. The `text_match` domain CHECK --! guarantees the `bf` *key* is present but not that it is an array, so a @@ -46,14 +46,14 @@ $$ LANGUAGE plpgsql; --! everything), matching set-containment semantics. --! --! @param val jsonb The encrypted payload. ---! @return eql_v3_internal.bloom_filter The `bf` array as a smallint[] domain value, or +--! @return {{prefix}}_internal.bloom_filter The `bf` array as a smallint[] domain value, or --! NULL when `bf` is absent or not a json array. -CREATE FUNCTION eql_v3_internal.bloom_filter(val jsonb) - RETURNS eql_v3_internal.bloom_filter +CREATE FUNCTION {{prefix}}_internal.bloom_filter(val jsonb) + RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ SELECT CASE WHEN jsonb_typeof(val -> 'bf') = 'array' - THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::eql_v3_internal.bloom_filter + THEN ARRAY(SELECT jsonb_array_elements(val -> 'bf'))::{{prefix}}_internal.bloom_filter END $$; diff --git a/packages/eql/src/v3/sem/bloom_filter/types.sql b/packages/eql/src/v3/sem/bloom_filter/types.sql index 618181e74..3c89db075 100644 --- a/packages/eql/src/v3/sem/bloom_filter/types.sql +++ b/packages/eql/src/v3/sem/bloom_filter/types.sql @@ -1,15 +1,15 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/sem/bloom_filter/types.sql ---! @brief Self-contained eql_v3 Bloom-filter SEM index-term type. +--! @brief Self-contained {{prefix}} Bloom-filter SEM index-term type. --! @brief Bloom-filter index term: a bit array stored as smallint[]. --! --! Backs the `matches` fuzzy-match capability (the public `@@` operator / ---! `eql_v3.matches`) on the text match/search domains. The filter is read from +--! `{{prefix}}.matches`) on the text match/search domains. The filter is read from --! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces --! to native `smallint[]` array-containment (`@>`) on this domain — inherited ---! through the base type — so a functional GIN index on `eql_v3.match_term(col)` +--! through the base type — so a functional GIN index on `{{prefix}}.match_term(col)` --! engages; this type itself needs no custom operators. --! --! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the @@ -18,4 +18,4 @@ --! domains now raise. Internally the `@@` wrapper still reduces to the base --! type's `@>` for GIN indexability. --! @note Self-contained: references no eql_v2 symbol. -CREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[]; +CREATE DOMAIN {{prefix}}_internal.bloom_filter AS smallint[]; diff --git a/packages/eql/src/v3/sem/hmac_256/functions.sql b/packages/eql/src/v3/sem/hmac_256/functions.sql index 1efb786bb..6724fd532 100644 --- a/packages/eql/src/v3/sem/hmac_256/functions.sql +++ b/packages/eql/src/v3/sem/hmac_256/functions.sql @@ -2,10 +2,10 @@ -- REQUIRE: src/v3/sem/hmac_256/types.sql --! @file v3/sem/hmac_256/functions.sql ---! @brief HMAC-SHA256 index-term extraction from a jsonb payload (eql_v3 SEM). +--! @brief HMAC-SHA256 index-term extraction from a jsonb payload ({{prefix}} SEM). --! --! jsonb-only subset of src/hmac_256/functions.sql. The encrypted-column and ---! ste_vec-entry overloads are intentionally omitted — the eql_v3 scalar +--! ste_vec-entry overloads are intentionally omitted — the {{prefix}} scalar --! domains extract from the jsonb payload directly via a cast to the domain. --! (Doc comments deliberately avoid naming eql_v2 symbols so the --! self-containment grep stays clean.) @@ -13,17 +13,17 @@ --! @brief Extract HMAC-SHA256 index term from JSONB payload --! --! Inlinable single-statement SQL — the planner can fold this into the calling ---! query so functional hash/btree indexes built on `eql_v3_internal.eq_term(col)` +--! query so functional hash/btree indexes built on `{{prefix}}_internal.eq_term(col)` --! (which calls this) engage structurally. --! --! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent -CREATE FUNCTION eql_v3_internal.hmac_256(val jsonb) - RETURNS eql_v3_internal.hmac_256 +--! @return {{prefix}}_internal.hmac_256 HMAC-SHA256 hash value, or NULL when `hm` is absent +CREATE FUNCTION {{prefix}}_internal.hmac_256(val jsonb) + RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT (val ->> 'hm')::eql_v3_internal.hmac_256 + SELECT (val ->> 'hm')::{{prefix}}_internal.hmac_256 $$; @@ -31,7 +31,7 @@ $$; --! --! @param val jsonb containing encrypted EQL payload --! @return boolean True if 'hm' field is present and non-null -CREATE FUNCTION eql_v3_internal.has_hmac_256(val jsonb) +CREATE FUNCTION {{prefix}}_internal.has_hmac_256(val jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE diff --git a/packages/eql/src/v3/sem/hmac_256/types.sql b/packages/eql/src/v3/sem/hmac_256/types.sql index eace5c2ed..49aea94fd 100644 --- a/packages/eql/src/v3/sem/hmac_256/types.sql +++ b/packages/eql/src/v3/sem/hmac_256/types.sql @@ -1,12 +1,12 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/sem/hmac_256/types.sql ---! @brief HMAC-SHA256 index term type (eql_v3 SEM) +--! @brief HMAC-SHA256 index term type ({{prefix}} SEM) --! --! Domain type representing HMAC-SHA256 hash values. Used for exact-match --! encrypted searches. The hash is stored in the 'hm' field of encrypted data ---! payloads. Self-contained eql_v3 copy (design D1/D3); the eql_v2 original is +--! payloads. Self-contained {{prefix}} copy (design D1/D3); the eql_v2 original is --! unchanged. --! --! @note Transient type used only during query execution. -CREATE DOMAIN eql_v3_internal.hmac_256 AS text; +CREATE DOMAIN {{prefix}}_internal.hmac_256 AS text; diff --git a/packages/eql/src/v3/sem/ope_cllw/functions.sql b/packages/eql/src/v3/sem/ope_cllw/functions.sql index 05509e761..9d038a2f5 100644 --- a/packages/eql/src/v3/sem/ope_cllw/functions.sql +++ b/packages/eql/src/v3/sem/ope_cllw/functions.sql @@ -2,17 +2,17 @@ -- REQUIRE: src/v3/sem/ope_cllw/types.sql --! @file v3/sem/ope_cllw/functions.sql ---! @brief CLLW OPE index-term extraction from a jsonb payload (eql_v3 SEM). +--! @brief CLLW OPE index-term extraction from a jsonb payload ({{prefix}} SEM). --! @brief Extract CLLW OPE index term from JSONB payload --! --! Returns the CLLW OPE ciphertext from the `op` field of an encrypted scalar ---! payload, hex-decoded to the bytea-backed eql_v3_internal.ope_cllw domain. +--! payload, hex-decoded to the bytea-backed {{prefix}}_internal.ope_cllw domain. --! --! Inlinable single-statement SQL — the body is a strict expression of the --! argument (`->>` and `decode` are both STRICT), so the planner folds this --! into the calling query and functional btree indexes built on ---! `eql_v3.ord_term(col)` (which calls this) engage structurally, the +--! `{{prefix}}.ord_term(col)` (which calls this) engage structurally, the --! same way the hmac_256 equality chain does. --! --! **Missing-`op` semantics**: `val ->> 'op'` is NULL when `op` is absent and @@ -20,14 +20,14 @@ --! btree's NULL handling filters those rows from range queries. --! --! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is +--! @return {{prefix}}_internal.ope_cllw Hex-decoded CLLW OPE term, or NULL when `op` is --! absent -CREATE FUNCTION eql_v3_internal.ope_cllw(val jsonb) - RETURNS eql_v3_internal.ope_cllw +CREATE FUNCTION {{prefix}}_internal.ope_cllw(val jsonb) + RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT decode(val ->> 'op', 'hex')::eql_v3_internal.ope_cllw + SELECT decode(val ->> 'op', 'hex')::{{prefix}}_internal.ope_cllw $$; -COMMENT ON FUNCTION eql_v3_internal.ope_cllw(jsonb) IS +COMMENT ON FUNCTION {{prefix}}_internal.ope_cllw(jsonb) IS 'eql-inline-critical: raw-jsonb CLLW OPE extractor; must stay inlinable (unpinned search_path)'; diff --git a/packages/eql/src/v3/sem/ope_cllw/types.sql b/packages/eql/src/v3/sem/ope_cllw/types.sql index 6321969fb..b27c193da 100644 --- a/packages/eql/src/v3/sem/ope_cllw/types.sql +++ b/packages/eql/src/v3/sem/ope_cllw/types.sql @@ -1,7 +1,7 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/sem/ope_cllw/types.sql ---! @brief CLLW OPE index term type for scalar range queries (eql_v3 SEM) +--! @brief CLLW OPE index term type for scalar range queries ({{prefix}} SEM) --! --! Domain type representing a CLLW (Copyless Logarithmic Width) --! Order-Preserving Encryption term. The ciphertext is stored hex-encoded in @@ -12,13 +12,13 @@ --! order-preserving under plain byte comparison, so the domain inherits --! bytea's native comparison operators and DEFAULT btree operator class --! outright — no hand-written operators, comparator, or operator class (the ---! same pattern as eql_v3_internal.hmac_256 over text). That keeps the whole +--! same pattern as {{prefix}}_internal.hmac_256 over text). That keeps the whole --! comparison chain inlinable, so a functional btree index on ---! `eql_v3.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` ---! domains' comparison operators. Contrast eql_v3_internal.ore_block_256 (`ob`), +--! `{{prefix}}.ord_term(col)` engages structurally for the `_ord` / `_ord_ope` +--! domains' comparison operators. Contrast {{prefix}}_internal.ore_block_256 (`ob`), --! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom --! N-block protocol. --! --! @note Transient type used only during query execution. ---! @see eql_v3_internal.ore_block_256 -CREATE DOMAIN eql_v3_internal.ope_cllw AS bytea; +--! @see {{prefix}}_internal.ore_block_256 +CREATE DOMAIN {{prefix}}_internal.ope_cllw AS bytea; diff --git a/packages/eql/src/v3/sem/ore_block_256/functions.sql b/packages/eql/src/v3/sem/ore_block_256/functions.sql index 45f31fdce..1d6108e18 100644 --- a/packages/eql/src/v3/sem/ore_block_256/functions.sql +++ b/packages/eql/src/v3/sem/ore_block_256/functions.sql @@ -4,7 +4,7 @@ -- REQUIRE: src/v3/sem/ore_block_256/types.sql --! @file v3/sem/ore_block_256/functions.sql ---! @brief ORE block construction, extraction, and comparison (eql_v3 SEM). +--! @brief ORE block construction, extraction, and comparison ({{prefix}} SEM). --! --! jsonb-only subset of src/ore_block_u64_8_256/functions.sql. The --! encrypted-column overloads are omitted; the helper jsonb_array_to_bytea_array @@ -16,7 +16,7 @@ --! @brief Convert JSONB array to ORE block composite type --! @internal --! @param val jsonb Array of hex-encoded ORE block terms ---! @return eql_v3_internal.ore_block_256 ORE block composite, or NULL if input is null +--! @return {{prefix}}_internal.ore_block_256 ORE block composite, or NULL if input is null --! @note plpgsql, not `LANGUAGE sql` (issue #353). The sole caller --! (`ore_block_256`) is itself plpgsql, so this function is NEVER reached --! from an inlinable context — as `LANGUAGE sql` it paid the per-call @@ -33,25 +33,25 @@ --! drops out of ordered queries). An empty array instead engages the --! comparator's `cardinality = 0` guard, which sorts empty BEFORE every --! non-empty term. See issue #262 (pinned by T7). -CREATE FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(val jsonb) -RETURNS eql_v3_internal.ore_block_256 +CREATE FUNCTION {{prefix}}_internal.jsonb_array_to_ore_block_256(val jsonb) +RETURNS {{prefix}}_internal.ore_block_256 IMMUTABLE AS $$ DECLARE - terms eql_v3_internal.ore_block_256_term[]; + terms {{prefix}}_internal.ore_block_256_term[]; BEGIN IF val IS NULL OR jsonb_typeof(val) != 'array' THEN RETURN NULL; END IF; - SELECT array_agg(ROW(b)::eql_v3_internal.ore_block_256_term) + SELECT array_agg(ROW(b)::{{prefix}}_internal.ore_block_256_term) INTO terms - FROM unnest(eql_v3_internal.jsonb_array_to_bytea_array(val)) AS b; + FROM unnest({{prefix}}_internal.jsonb_array_to_bytea_array(val)) AS b; -- plpgsql pitfall: `SELECT INTO ` assigns the -- select-list columns FIELD-WISE into the variable — return the row -- constructor directly instead. The COALESCE stays load-bearing for the -- empty-`ob` case (issue #262): array_agg over zero rows yields NULL, and -- the comparator needs an EMPTY terms array, not NULL terms. - RETURN ROW(COALESCE(terms, ARRAY[]::eql_v3_internal.ore_block_256_term[]))::eql_v3_internal.ore_block_256; + RETURN ROW(COALESCE(terms, ARRAY[]::{{prefix}}_internal.ore_block_256_term[]))::{{prefix}}_internal.ore_block_256; END; $$ LANGUAGE plpgsql; @@ -62,24 +62,24 @@ $$ LANGUAGE plpgsql; --! It takes a bare `jsonb` arg (not a jsonb-backed encrypted DOMAIN), so the --! structural skip in tasks/pin_search_path_v3.sql does not recognise it; --! this marker is the documented manual opt-in. -COMMENT ON FUNCTION eql_v3_internal.jsonb_array_to_ore_block_256(jsonb) IS +COMMENT ON FUNCTION {{prefix}}_internal.jsonb_array_to_ore_block_256(jsonb) IS 'eql-inline-critical: per-encrypted-value ORE opclass-path helper; must stay unpinned (SET search_path adds per-call overhead)'; --! @brief Extract ORE block index term from JSONB payload --! @param val jsonb containing encrypted EQL payload ---! @return eql_v3_internal.ore_block_256 ORE block index term +--! @return {{prefix}}_internal.ore_block_256 ORE block index term --! @throws Exception if 'ob' field is missing -CREATE FUNCTION eql_v3_internal.ore_block_256(val jsonb) - RETURNS eql_v3_internal.ore_block_256 +CREATE FUNCTION {{prefix}}_internal.ore_block_256(val jsonb) + RETURNS {{prefix}}_internal.ore_block_256 IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ BEGIN -- Declared STRICT: PostgreSQL returns NULL for a NULL argument without -- entering the body, so no explicit `val IS NULL` guard is needed. - IF eql_v3_internal.has_ore_block_256(val) THEN - RETURN eql_v3_internal.jsonb_array_to_ore_block_256(val->'ob'); + IF {{prefix}}_internal.has_ore_block_256(val) THEN + RETURN {{prefix}}_internal.jsonb_array_to_ore_block_256(val->'ob'); END IF; RAISE 'Expected an ore index (ob) value in json: %', val; END; @@ -97,7 +97,7 @@ $$ LANGUAGE plpgsql; --! previous `val ->> 'ob' IS NOT NULL` form stringified scalars/objects and so --! reported them as present. `{}` (absent `ob`) and `{"ob": null}` (JSON null) --! both remain `false`. -CREATE FUNCTION eql_v3_internal.has_ore_block_256(val jsonb) +CREATE FUNCTION {{prefix}}_internal.has_ore_block_256(val jsonb) RETURNS boolean IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -110,8 +110,8 @@ $$ LANGUAGE plpgsql; --! @brief Compare two ORE block terms using cryptographic comparison --! @internal ---! @param a eql_v3_internal.ore_block_256_term First ORE term ---! @param b eql_v3_internal.ore_block_256_term Second ORE term +--! @param a {{prefix}}_internal.ore_block_256_term First ORE term +--! @param b {{prefix}}_internal.ore_block_256_term Second ORE term --! @return integer -1 if a < b, 0 if a = b, 1 if a > b --! @throws Exception if ciphertexts are different lengths --! @note Marked `IMMUTABLE` (the three `compare_ore_block_256_term(s)` @@ -121,7 +121,7 @@ $$ LANGUAGE plpgsql; --! is itself `IMMUTABLE STRICT PARALLEL SAFE` — so `IMMUTABLE` lets the --! planner fold/cache these in ordering and index contexts. NOT `STRICT`: --! the NULL-handling branches below are load-bearing for the array overload. -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_term(a eql_v3_internal.ore_block_256_term, b eql_v3_internal.ore_block_256_term) +CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_term(a {{prefix}}_internal.ore_block_256_term, b {{prefix}}_internal.ore_block_256_term) RETURNS integer IMMUTABLE SET search_path = pg_catalog, extensions, public @@ -221,10 +221,10 @@ $$ LANGUAGE plpgsql; --! @brief Compare arrays of ORE block terms recursively --! @internal ---! @param a eql_v3_internal.ore_block_256_term[] First array ---! @param b eql_v3_internal.ore_block_256_term[] Second array +--! @param a {{prefix}}_internal.ore_block_256_term[] First array +--! @param b {{prefix}}_internal.ore_block_256_term[] Second array --! @return integer -1/0/1, or NULL if either array is NULL -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256_term[], b eql_v3_internal.ore_block_256_term[]) +CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256_term[], b {{prefix}}_internal.ore_block_256_term[]) RETURNS integer IMMUTABLE SET search_path = pg_catalog, extensions, public @@ -248,10 +248,10 @@ AS $$ RETURN 1; END IF; - cmp_result := eql_v3_internal.compare_ore_block_256_term(a[1], b[1]); + cmp_result := {{prefix}}_internal.compare_ore_block_256_term(a[1], b[1]); IF cmp_result = 0 THEN - RETURN eql_v3_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); + RETURN {{prefix}}_internal.compare_ore_block_256_terms(a[2:array_length(a,1)], b[2:array_length(b,1)]); END IF; RETURN cmp_result; @@ -261,15 +261,15 @@ $$ LANGUAGE plpgsql; --! @brief Compare ORE block composite types --! @internal ---! @param a eql_v3_internal.ore_block_256 First ORE block ---! @param b eql_v3_internal.ore_block_256 Second ORE block +--! @param a {{prefix}}_internal.ore_block_256 First ORE block +--! @param b {{prefix}}_internal.ore_block_256 Second ORE block --! @return integer -1/0/1 -CREATE FUNCTION eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +CREATE FUNCTION {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS integer IMMUTABLE SET search_path = pg_catalog, extensions, public AS $$ BEGIN - RETURN eql_v3_internal.compare_ore_block_256_terms(a.terms, b.terms); + RETURN {{prefix}}_internal.compare_ore_block_256_terms(a.terms, b.terms); END $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/sem/ore_block_256/operator_class.sql b/packages/eql/src/v3/sem/ore_block_256/operator_class.sql index 7e56ad383..b889c5cd9 100644 --- a/packages/eql/src/v3/sem/ore_block_256/operator_class.sql +++ b/packages/eql/src/v3/sem/ore_block_256/operator_class.sql @@ -4,10 +4,10 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file v3/sem/ore_block_256/operator_class.sql ---! @brief B-tree operator family + default class on eql_v3_internal.ore_block_256. +--! @brief B-tree operator family + default class on {{prefix}}_internal.ore_block_256. --! --! Gives the composite type its DEFAULT btree opclass so the recommended ---! functional index `CREATE INDEX ON t (eql_v3.ord_term_ore(col))` engages without +--! functional index `CREATE INDEX ON t ({{prefix}}.ord_term_ore(col))` engages without --! an explicit opclass annotation (design D4). --! --! @note Creating an operator family/class requires superuser: Postgres forbids @@ -16,32 +16,32 @@ --! the installer as a non-superuser role, so the DO block below ATTEMPTS --! the creation and skips it on insufficient_privilege (SQLSTATE 42501), --! letting the single installer run everywhere. When the class is absent, ---! ORE ordered scans over eql_v3_internal.ore_block_256 are unavailable, +--! ORE ordered scans over {{prefix}}_internal.ore_block_256 are unavailable, --! but the order-preserving (OPE) ordering domains — whose extractor --! return types carry a native btree opclass — still index without it. On --! superuser installs (self-managed Postgres, the SQLx test matrix) the --! class is created normally. Any non-privilege error still propagates. ---! @see eql_v3_internal.compare_ore_block_256_terms +--! @see {{prefix}}_internal.compare_ore_block_256_terms DO $do$ BEGIN - EXECUTE 'CREATE OPERATOR FAMILY eql_v3_internal.ore_block_256_operator_family USING btree'; + EXECUTE 'CREATE OPERATOR FAMILY {{prefix}}_internal.ore_block_256_operator_family USING btree'; EXECUTE $ddl$ - CREATE OPERATOR CLASS eql_v3_internal.ore_block_256_operator_class - DEFAULT FOR TYPE eql_v3_internal.ore_block_256 - USING btree FAMILY eql_v3_internal.ore_block_256_operator_family AS + CREATE OPERATOR CLASS {{prefix}}_internal.ore_block_256_operator_class + DEFAULT FOR TYPE {{prefix}}_internal.ore_block_256 + USING btree FAMILY {{prefix}}_internal.ore_block_256_operator_family AS OPERATOR 1 public.<, OPERATOR 2 public.<=, OPERATOR 3 public.=, OPERATOR 4 public.>=, OPERATOR 5 public.>, - FUNCTION 1 eql_v3_internal.compare_ore_block_256_terms(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) + FUNCTION 1 {{prefix}}_internal.compare_ore_block_256_terms(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) $ddl$; - RAISE NOTICE 'EQL: created btree operator class eql_v3_internal.ore_block_256_operator_class'; + RAISE NOTICE 'EQL: created btree operator class {{prefix}}_internal.ore_block_256_operator_class'; EXCEPTION WHEN insufficient_privilege THEN - RAISE NOTICE 'EQL: skipped operator class eql_v3_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected'; + RAISE NOTICE 'EQL: skipped operator class {{prefix}}_internal.ore_block_256_operator_class (requires superuser); ORE ordered indexes on ore_block_256 unavailable, OPE ordering domains unaffected'; END; $do$; diff --git a/packages/eql/src/v3/sem/ore_block_256/operators.sql b/packages/eql/src/v3/sem/ore_block_256/operators.sql index 7b8b2caac..cdd4c9df3 100644 --- a/packages/eql/src/v3/sem/ore_block_256/operators.sql +++ b/packages/eql/src/v3/sem/ore_block_256/operators.sql @@ -3,105 +3,105 @@ -- REQUIRE: src/v3/sem/ore_block_256/functions.sql --! @file v3/sem/ore_block_256/operators.sql ---! @brief Comparison operators on eql_v3_internal.ore_block_256. +--! @brief Comparison operators on {{prefix}}_internal.ore_block_256. --! --! The six backing functions are inlinable single-statement SQL so the planner ---! can fold the eql_v3 comparison wrappers through to functional-index matching. +--! can fold the {{prefix}} comparison wrappers through to functional-index matching. --! @brief Equality backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the ORE blocks are equal --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_eq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_eq(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 0 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = 0 $$; --! @brief Not-equal backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the ORE blocks are not equal --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_neq(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_neq(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) <> 0 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) <> 0 $$; --! @brief Less-than backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the left operand is less than the right operand --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_lt(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = -1 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = -1 $$; --! @brief Less-than-or-equal backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the left operand is less than or equal to the right operand --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_lte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_lte(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != 1 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) != 1 $$; --! @brief Greater-than backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the left operand is greater than the right operand --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gt(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_gt(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) = 1 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) = 1 $$; --! @brief Greater-than-or-equal backing function for ORE block types --! @internal --! ---! @param a eql_v3_internal.ore_block_256 Left operand ---! @param b eql_v3_internal.ore_block_256 Right operand +--! @param a {{prefix}}_internal.ore_block_256 Left operand +--! @param b {{prefix}}_internal.ore_block_256 Right operand --! @return boolean True if the left operand is greater than or equal to the right operand --! ---! @see eql_v3_internal.compare_ore_block_256_terms -CREATE FUNCTION eql_v3_internal.ore_block_256_gte(a eql_v3_internal.ore_block_256, b eql_v3_internal.ore_block_256) +--! @see {{prefix}}_internal.compare_ore_block_256_terms +CREATE FUNCTION {{prefix}}_internal.ore_block_256_gte(a {{prefix}}_internal.ore_block_256, b {{prefix}}_internal.ore_block_256) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS $$ - SELECT eql_v3_internal.compare_ore_block_256_terms(a, b) != -1 + SELECT {{prefix}}_internal.compare_ore_block_256_terms(a, b) != -1 $$; @@ -110,11 +110,11 @@ $$; --! COMMUTATOR is the operator itself: equality is symmetric. Required for the --! MERGES flag — without it the planner raises "could not find commutator" the --! first time an ore_block equality is used as a join qual (e.g. via the inlined ---! eql_v3_internal._ord_ore equality wrappers). +--! {{prefix}}_internal._ord_ore equality wrappers). CREATE OPERATOR public.= ( - FUNCTION=eql_v3_internal.ore_block_256_eq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_eq, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.=), NEGATOR = OPERATOR(public.<>), RESTRICT = eqsel, @@ -125,9 +125,9 @@ CREATE OPERATOR public.= ( --! @brief <> operator for ORE block types CREATE OPERATOR public.<> ( - FUNCTION=eql_v3_internal.ore_block_256_neq, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_neq, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.<>), NEGATOR = OPERATOR(public.=), RESTRICT = neqsel, @@ -137,9 +137,9 @@ CREATE OPERATOR public.<> ( --! @brief > operator for ORE block types CREATE OPERATOR public.> ( - FUNCTION=eql_v3_internal.ore_block_256_gt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_gt, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.<), NEGATOR = OPERATOR(public.<=), RESTRICT = scalargtsel, @@ -148,9 +148,9 @@ CREATE OPERATOR public.> ( --! @brief < operator for ORE block types CREATE OPERATOR public.< ( - FUNCTION=eql_v3_internal.ore_block_256_lt, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_lt, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.>), NEGATOR = OPERATOR(public.>=), RESTRICT = scalarltsel, @@ -159,9 +159,9 @@ CREATE OPERATOR public.< ( --! @brief <= operator for ORE block types CREATE OPERATOR public.<= ( - FUNCTION=eql_v3_internal.ore_block_256_lte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_lte, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.>=), NEGATOR = OPERATOR(public.>), RESTRICT = scalarlesel, @@ -170,9 +170,9 @@ CREATE OPERATOR public.<= ( --! @brief >= operator for ORE block types CREATE OPERATOR public.>= ( - FUNCTION=eql_v3_internal.ore_block_256_gte, - LEFTARG=eql_v3_internal.ore_block_256, - RIGHTARG=eql_v3_internal.ore_block_256, + FUNCTION={{prefix}}_internal.ore_block_256_gte, + LEFTARG={{prefix}}_internal.ore_block_256, + RIGHTARG={{prefix}}_internal.ore_block_256, COMMUTATOR = OPERATOR(public.<=), NEGATOR = OPERATOR(public.<), RESTRICT = scalargesel, diff --git a/packages/eql/src/v3/sem/ore_block_256/types.sql b/packages/eql/src/v3/sem/ore_block_256/types.sql index 608610238..b697ddaf6 100644 --- a/packages/eql/src/v3/sem/ore_block_256/types.sql +++ b/packages/eql/src/v3/sem/ore_block_256/types.sql @@ -1,16 +1,16 @@ -- REQUIRE: src/v3/schema.sql --! @file v3/sem/ore_block_256/types.sql ---! @brief ORE block index-term types (eql_v3 SEM). +--! @brief ORE block index-term types ({{prefix}} SEM). --! ---! Self-contained eql_v3 copies of the Order-Revealing Encryption block types +--! Self-contained {{prefix}} copies of the Order-Revealing Encryption block types --! (design D1/D3). The eql_v2 originals are unchanged. --! @brief ORE block term type for Order-Revealing Encryption --! --! Composite type representing a single ORE block term. Stores encrypted data --! as bytea that enables range comparisons without decryption. -CREATE TYPE eql_v3_internal.ore_block_256_term AS ( +CREATE TYPE {{prefix}}_internal.ore_block_256_term AS ( bytes bytea ); @@ -21,6 +21,6 @@ CREATE TYPE eql_v3_internal.ore_block_256_term AS ( --! in the 'ob' field of encrypted data payloads. --! --! @note Transient type used only during query execution. -CREATE TYPE eql_v3_internal.ore_block_256 AS ( - terms eql_v3_internal.ore_block_256_term[] +CREATE TYPE {{prefix}}_internal.ore_block_256 AS ( + terms {{prefix}}_internal.ore_block_256_term[] ); diff --git a/packages/eql/src/v3/version.template b/packages/eql/src/v3/version.template index 828635352..bc546f8a9 100644 --- a/packages/eql/src/v3/version.template +++ b/packages/eql/src/v3/version.template @@ -2,10 +2,10 @@ -- Source is src/v3/version.template -- REQUIRE: src/v3/schema.sql -DROP FUNCTION IF EXISTS eql_v3.version(); +DROP FUNCTION IF EXISTS {{prefix}}.version(); --! @file v3/version.sql ---! @brief EQL version reporting (self-contained eql_v3 surface) +--! @brief EQL version reporting (self-contained {{prefix}} surface) --! --! This file is auto-generated from src/v3/version.template during build. --! The $RELEASE_VERSION placeholder is replaced with the actual release @@ -21,9 +21,9 @@ DROP FUNCTION IF EXISTS eql_v3.version(); --! --! @note Auto-generated during build from src/v3/version.template --! ---! Example: `SELECT eql_v3.version()` returns the installed version string, +--! Example: `SELECT {{prefix}}.version()` returns the installed version string, --! e.g. `'3.0.0'` (or `'DEV'` for development builds). -CREATE FUNCTION eql_v3.version() +CREATE FUNCTION {{prefix}}.version() RETURNS text IMMUTABLE STRICT PARALLEL SAFE AS $$ @@ -32,6 +32,6 @@ $$ 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 '$RELEASE_VERSION'; +--! Mirrors {{prefix}}.version() as a comment on the schema so the installed +--! version can also be read via obj_description('{{prefix}}'::regnamespace). +COMMENT ON SCHEMA {{prefix}} IS '$RELEASE_VERSION'; diff --git a/packages/eql/tasks/build.sh b/packages/eql/tasks/build.sh index cf8cd28d1..77217c8c1 100755 --- a/packages/eql/tasks/build.sh +++ b/packages/eql/tasks/build.sh @@ -2,7 +2,7 @@ #MISE description="Build SQL into single release file" #MISE alias="b" #MISE sources=["src/v3/**/*.sql", "src/v3/version.template", "tasks/pin_search_path_v3.sql", "tasks/uninstall-v3.sql", "crates/eql-domains/src/**/*.rs", "crates/eql-codegen/src/**/*.rs", "Cargo.toml", "Cargo.lock", "crates/eql-codegen/Cargo.toml", "crates/eql-domains/Cargo.toml", "tasks/build/ordering.sh", "tasks/test/verify_symbol_order_v3.sh", "tasks/test/verify_installer_complete.sh", "tasks/test/symbol_order_allowlist.txt"] -#MISE outputs=["release/cipherstash-encrypt.sql","release/cipherstash-encrypt-uninstall.sql","src/deps-ordered-v3.txt"] +#MISE outputs=["release/cipherstash-encrypt.sql","release/cipherstash-encrypt-uninstall.sql","src/deps-ordered-v3.txt","build/render/eql_v3/deps-ordered.txt"] #USAGE flag "--version " help="Specify release version of EQL" default="DEV" #!/bin/bash @@ -80,23 +80,44 @@ sed "s/\$RELEASE_VERSION/$RELEASE_VERSION/g" src/v3/version.template > src/v3/ve cargo run -q -p eql-codegen -- order > src/deps-ordered-v3.txt.tmp mv src/deps-ordered-v3.txt.tmp src/deps-ordered-v3.txt -bash tasks/test/verify_symbol_order_v3.sh src/deps-ordered-v3.txt - -: > release/cipherstash-encrypt.sql -while IFS= read -r f; do - strip_require_lines "$f" >> release/cipherstash-encrypt.sql -done < src/deps-ordered-v3.txt -cat tasks/pin_search_path_v3.sql >> release/cipherstash-encrypt.sql - -# `eql-codegen order` guarantees the ORDER contains every file on disk. This gate -# closes the layer below — that the concat loop above actually emitted each ordered -# file's body. 93 of the ~244 v3 files are leaves (required by nothing, defining -# nothing another file references), so dropping one yields an installer that applies -# cleanly and passes the symbol checker while silently shipping less than it should. -bash tasks/test/verify_installer_complete.sh src/deps-ordered-v3.txt release/cipherstash-encrypt.sql - -cat tasks/uninstall-v3.sql >> release/cipherstash-encrypt-uninstall.sql - +# The source names its schemas and payload version by placeholder +# ({{prefix}}, {{eql_version}}; ADR-0002), so it is not installable SQL until it +# is rendered. Render the ordered files, the pin script and the uninstaller as +# EQL v3 into build/render/eql_v3/ (same relative paths), then run every gate +# and assemble the installer from the rendered tree. `eql-codegen render` fails +# on an unknown placeholder and on a literal eql_v3/eql_v4 in the source, and +# writes nothing unless every file renders. +assemble() { + local version=$1 installer=$2 uninstaller=$3 + local root="build/render/eql_v${version}" + local ordered="$root/deps-ordered.txt" + + rm -rf "$root" + # shellcheck disable=SC2046 # one path per line, none with spaces + cargo run -q -p eql-codegen -- render "$version" "$root" \ + $(cat src/deps-ordered-v3.txt) tasks/pin_search_path_v3.sql tasks/uninstall-v3.sql + sed "s|^|$root/|" src/deps-ordered-v3.txt > "$ordered" + + bash tasks/test/verify_symbol_order_v3.sh "$ordered" + + : > "$installer" + while IFS= read -r f; do + strip_require_lines "$f" >> "$installer" + done < "$ordered" + cat "$root/tasks/pin_search_path_v3.sql" >> "$installer" + + # `eql-codegen order` guarantees the ORDER contains every file on disk. This + # gate closes the layer below — that the concat loop above actually emitted + # each ordered file's body. 93 of the ~244 v3 files are leaves (required by + # nothing, defining nothing another file references), so dropping one yields + # an installer that applies cleanly and passes the symbol checker while + # silently shipping less than it should. + bash tasks/test/verify_installer_complete.sh "$ordered" "$installer" "$root" + + cat "$root/tasks/uninstall-v3.sql" > "$uninstaller" +} + +assemble 3 release/cipherstash-encrypt.sql release/cipherstash-encrypt-uninstall.sql echo echo '###############################################' diff --git a/packages/eql/tasks/docs/doxygen-filter.sh b/packages/eql/tasks/docs/doxygen-filter.sh index fe00c19ab..4d61b7b82 100755 --- a/packages/eql/tasks/docs/doxygen-filter.sh +++ b/packages/eql/tasks/docs/doxygen-filter.sh @@ -10,8 +10,10 @@ if [ "$#" -ne 1 ]; then exit 2 fi -# Prepares SQL for Doxygen's C++ parser. Four transforms: +# Prepares SQL for Doxygen's C++ parser. Five transforms: # +# 0. Render the {{prefix}} / {{eql_version}} placeholders (ADR-0002) as EQL v3, +# so the reference names `eql_v3.eq_term`, not `{{prefix}}.eq_term`. # 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. @@ -102,4 +104,4 @@ awk ' gsub(/--/, "//", out) print out } -' "$1" +' < <(sed -e 's/{{prefix}}/eql_v3/g' -e 's/{{eql_version}}/3/g' "$1") diff --git a/packages/eql/tasks/docs/validate/documented-sql.sh b/packages/eql/tasks/docs/validate/documented-sql.sh index 9ce3fb348..60d954768 100755 --- a/packages/eql/tasks/docs/validate/documented-sql.sh +++ b/packages/eql/tasks/docs/validate/documented-sql.sh @@ -10,7 +10,10 @@ PGPORT=${PGPORT:-7432} PGUSER=${PGUSER:-cipherstash} PGPASSWORD=${PGPASSWORD:-password} PGDATABASE=${PGDATABASE:-postgres} -source_directory="src" +# The rendered eql_v3 tree, not src/: the source writes its schemas and payload +# version as {{prefix}} / {{eql_version}} placeholders (ADR-0002), which psql +# cannot parse. `mise run build` renders it. +source_directory="build/render/eql_v3/src" echo "Validating SQL syntax for all documented files..." echo "" diff --git a/packages/eql/tasks/pin_search_path_v3.sql b/packages/eql/tasks/pin_search_path_v3.sql index 9718b161b..dd67ec1c2 100644 --- a/packages/eql/tasks/pin_search_path_v3.sql +++ b/packages/eql/tasks/pin_search_path_v3.sql @@ -1,11 +1,11 @@ --! @file pin_search_path_v3.sql ---! @brief Post-install: pin search_path on every eql_v3.* function. +--! @brief Post-install: pin search_path on every {{prefix}}.* function. --! --! Appended verbatim by `tasks/build.sh` to the end of the v3-only release --! artifact, AFTER all src/v3/**/*.sql files have been concatenated. It lives --! outside src/ so it stays out of the dependency graph. --! ---! Iterates over functions in the `eql_v3` and `eql_v3_internal` schemas and +--! Iterates over functions in the `{{prefix}}` and `{{prefix}}_internal` schemas and --! applies a fixed `search_path` via `ALTER FUNCTION ... SET search_path = ...`, --! satisfying Supabase splinter's `function_search_path_mutable` lint. --! @@ -32,19 +32,19 @@ BEGIN RAISE EXCEPTION 'pin_search_path_v3: type pg_catalog.jsonb not found'; END IF; - -- eql_v3 SEM index-term functions that must stay inlinable for - -- functional-index matching (no SET, IMMUTABLE). Mirrors the eql_v3 clause + -- {{prefix}} SEM index-term functions that must stay inlinable for + -- functional-index matching (no SET, IMMUTABLE). Mirrors the {{prefix}} clause -- in the legacy combined pin_search_path.sql. SELECT pg_catalog.array_agg(p.oid) INTO inline_critical_oids FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas()) AND ( (p.pronargs = 2 AND p.proname IN ('ore_block_256_eq', 'ore_block_256_neq', 'ore_block_256_lt', 'ore_block_256_lte', 'ore_block_256_gt', 'ore_block_256_gte')) - -- The CLLW-OPE surface is the extractor alone: eql_v3_internal.ope_cllw is a + -- The CLLW-OPE surface is the extractor alone: {{prefix}}_internal.ope_cllw is a -- domain over bytea (native comparison operators and btree opclass), -- so there are no ope-specific comparison functions to keep inlinable. OR (p.pronargs = 1 @@ -62,7 +62,7 @@ BEGIN SELECT p.oid FROM pg_catalog.pg_proc p JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace - WHERE n.nspname = ANY(eql_v3_internal.owned_schemas()) + WHERE n.nspname = ANY({{prefix}}_internal.owned_schemas()) AND p.prokind IN ('f', 'w') AND NOT EXISTS ( SELECT 1 FROM pg_catalog.unnest(coalesce(p.proconfig, '{}'::text[])) c @@ -86,7 +86,7 @@ BEGIN AND dt.typbasetype = jsonb_oid AND ( dn.nspname = 'public' - OR dn.nspname = ANY(eql_v3_internal.owned_schemas()) + OR dn.nspname = ANY({{prefix}}_internal.owned_schemas()) ) ) ) diff --git a/packages/eql/tasks/test/docs_v3_grep.sh b/packages/eql/tasks/test/docs_v3_grep.sh index 14cc27c67..c0f9d149a 100755 --- a/packages/eql/tasks/test/docs_v3_grep.sh +++ b/packages/eql/tasks/test/docs_v3_grep.sh @@ -64,7 +64,7 @@ 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) +ste_vec_alias_count=$(grep -c '^CREATE FUNCTION {{prefix}}\.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 diff --git a/packages/eql/tasks/test/verify_installer_complete.sh b/packages/eql/tasks/test/verify_installer_complete.sh index 7f0263ef8..9bb9ad8fa 100755 --- a/packages/eql/tasks/test/verify_installer_complete.sh +++ b/packages/eql/tasks/test/verify_installer_complete.sh @@ -24,9 +24,12 @@ set -euo pipefail REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" cd "$REPO_ROOT" -ORDERED="${1:-src/deps-ordered-v3.txt}" +ORDERED="${1:-build/render/eql_v3/deps-ordered.txt}" INSTALLER="${2:-release/cipherstash-encrypt.sql}" -PIN="tasks/pin_search_path_v3.sql" +# The rendered tree the ordered paths point into (build.sh renders the +# placeholder source into build/render/eql_v/, keeping relative paths). +ROOT="${3:-build/render/eql_v3}" +PIN="$ROOT/tasks/pin_search_path_v3.sql" for f in "$ORDERED" "$INSTALLER" "$PIN"; do if [[ ! -f "$f" ]]; then @@ -73,7 +76,7 @@ fail=0 echo "==> Non-vacuity gate: the order names every src/v3 SQL file" work="$(mktemp -d)" trap 'rm -rf "$work"' EXIT -find src/v3 -type f -name '*.sql' ! -name '*_test.sql' | LC_ALL=C sort > "$work/disk" +find "$ROOT/src/v3" -type f -name '*.sql' ! -name '*_test.sql' | LC_ALL=C sort > "$work/disk" grep -v '^[[:space:]]*$' "$ORDERED" | LC_ALL=C sort > "$work/order" || true n_disk=$(count_lines "$work/disk") diff --git a/packages/eql/tasks/test/verify_symbol_order_v3.sh b/packages/eql/tasks/test/verify_symbol_order_v3.sh index 1d859d527..58bfff08f 100755 --- a/packages/eql/tasks/test/verify_symbol_order_v3.sh +++ b/packages/eql/tasks/test/verify_symbol_order_v3.sh @@ -56,7 +56,7 @@ set -euo pipefail REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" cd "$REPO_ROOT" -ORDERED="${1:-src/deps-ordered-v3.txt}" +ORDERED="${1:-build/render/eql_v3/deps-ordered.txt}" # Overridable so the self-test can exercise the missing-allowlist path without # disturbing the committed one. ALLOW="${SYMBOL_ORDER_ALLOWLIST:-tasks/test/symbol_order_allowlist.txt}" diff --git a/packages/eql/tasks/uninstall-v3.sql b/packages/eql/tasks/uninstall-v3.sql index 7c9dd57f1..d1cfb7248 100644 --- a/packages/eql/tasks/uninstall-v3.sql +++ b/packages/eql/tasks/uninstall-v3.sql @@ -1,8 +1,8 @@ --- Uninstall the standalone eql_v3 surface. CASCADE removes the domains, SEM --- types, operators, opclass, and any columns typed with the eql_v3 domains. -DROP SCHEMA IF EXISTS eql_v3 CASCADE; +-- Uninstall the standalone {{prefix}} surface. CASCADE removes the domains, SEM +-- types, operators, opclass, and any columns typed with the {{prefix}} domains. +DROP SCHEMA IF EXISTS {{prefix}} CASCADE; --- Drop the internal implementation schema after eql_v3 (eql_v3's extractors and --- operators depend on eql_v3_internal types; dropping eql_v3 first with CASCADE --- removes those dependents, then eql_v3_internal drops cleanly). -DROP SCHEMA IF EXISTS eql_v3_internal CASCADE; +-- Drop the internal implementation schema after {{prefix}} ({{prefix}}'s extractors and +-- operators depend on {{prefix}}_internal types; dropping {{prefix}} first with CASCADE +-- removes those dependents, then {{prefix}}_internal drops cleanly). +DROP SCHEMA IF EXISTS {{prefix}}_internal CASCADE; From 679ac8881825607fdf2b5f2b5d8dd60e85e752e5 Mon Sep 17 00:00:00 2001 From: Dan Draper Date: Sat, 10 Oct 2026 10:15:03 +1100 Subject: [PATCH 2/3] chore(eql): regenerate the scalar SQL surface with placeholders Output of `cargo run -p eql-codegen` after the previous commit; no hand edits. `mise run codegen:parity` reproduces it. Only v3 is rendered so far, and the installer and uninstaller built from this commit are byte-identical to the ones built before the placeholders. Refs #1141 --- .../v3/scalars/bigint/bigint_eq_functions.sql | 504 ++++++++--------- .../v3/scalars/bigint/bigint_eq_operators.sql | 190 +++---- .../v3/scalars/bigint/bigint_functions.sql | 504 ++++++++--------- .../v3/scalars/bigint/bigint_operators.sql | 190 +++---- .../scalars/bigint/bigint_ord_aggregates.sql | 54 +- .../scalars/bigint/bigint_ord_functions.sql | 480 ++++++++--------- .../bigint/bigint_ord_ope_aggregates.sql | 54 +- .../bigint/bigint_ord_ope_functions.sql | 480 ++++++++--------- .../bigint/bigint_ord_ope_operators.sql | 190 +++---- .../scalars/bigint/bigint_ord_operators.sql | 190 +++---- .../bigint/bigint_ord_ore_aggregates.sql | 54 +- .../bigint/bigint_ord_ore_functions.sql | 480 ++++++++--------- .../bigint/bigint_ord_ore_operators.sql | 190 +++---- .../src/v3/scalars/bigint/bigint_types.sql | 50 +- .../bigint/json_entry_bigint_functions.sql | 258 ++++----- .../bigint/json_entry_bigint_operators.sql | 98 ++-- .../bigint/query_bigint_eq_functions.sql | 54 +- .../bigint/query_bigint_eq_operators.sql | 18 +- .../bigint/query_bigint_ord_functions.sql | 134 ++--- .../bigint/query_bigint_ord_ope_functions.sql | 134 ++--- .../bigint/query_bigint_ord_ope_operators.sql | 50 +- .../bigint/query_bigint_ord_operators.sql | 50 +- .../bigint/query_bigint_ord_ore_functions.sql | 134 ++--- .../bigint/query_bigint_ord_ore_operators.sql | 50 +- .../v3/scalars/bigint/query_bigint_types.sql | 44 +- .../v3/scalars/boolean/boolean_functions.sql | 504 ++++++++--------- .../v3/scalars/boolean/boolean_operators.sql | 190 +++---- .../src/v3/scalars/boolean/boolean_types.sql | 10 +- .../src/v3/scalars/date/date_eq_functions.sql | 504 ++++++++--------- .../src/v3/scalars/date/date_eq_operators.sql | 190 +++---- .../src/v3/scalars/date/date_functions.sql | 504 ++++++++--------- .../src/v3/scalars/date/date_operators.sql | 190 +++---- .../v3/scalars/date/date_ord_aggregates.sql | 54 +- .../v3/scalars/date/date_ord_functions.sql | 480 ++++++++--------- .../scalars/date/date_ord_ope_aggregates.sql | 54 +- .../scalars/date/date_ord_ope_functions.sql | 480 ++++++++--------- .../scalars/date/date_ord_ope_operators.sql | 190 +++---- .../v3/scalars/date/date_ord_operators.sql | 190 +++---- .../scalars/date/date_ord_ore_aggregates.sql | 54 +- .../scalars/date/date_ord_ore_functions.sql | 480 ++++++++--------- .../scalars/date/date_ord_ore_operators.sql | 190 +++---- .../eql/src/v3/scalars/date/date_types.sql | 50 +- .../date/json_entry_date_functions.sql | 290 +++++----- .../date/json_entry_date_operators.sql | 98 ++-- .../scalars/date/query_date_eq_functions.sql | 54 +- .../scalars/date/query_date_eq_operators.sql | 18 +- .../scalars/date/query_date_ord_functions.sql | 134 ++--- .../date/query_date_ord_ope_functions.sql | 134 ++--- .../date/query_date_ord_ope_operators.sql | 50 +- .../scalars/date/query_date_ord_operators.sql | 50 +- .../date/query_date_ord_ore_functions.sql | 134 ++--- .../date/query_date_ord_ore_operators.sql | 50 +- .../src/v3/scalars/date/query_date_types.sql | 44 +- .../v3/scalars/double/double_eq_functions.sql | 504 ++++++++--------- .../v3/scalars/double/double_eq_operators.sql | 190 +++---- .../v3/scalars/double/double_functions.sql | 504 ++++++++--------- .../v3/scalars/double/double_operators.sql | 190 +++---- .../scalars/double/double_ord_aggregates.sql | 54 +- .../scalars/double/double_ord_functions.sql | 480 ++++++++--------- .../double/double_ord_ope_aggregates.sql | 54 +- .../double/double_ord_ope_functions.sql | 480 ++++++++--------- .../double/double_ord_ope_operators.sql | 190 +++---- .../scalars/double/double_ord_operators.sql | 190 +++---- .../double/double_ord_ore_aggregates.sql | 54 +- .../double/double_ord_ore_functions.sql | 480 ++++++++--------- .../double/double_ord_ore_operators.sql | 190 +++---- .../src/v3/scalars/double/double_types.sql | 50 +- .../double/json_entry_double_functions.sql | 258 ++++----- .../double/json_entry_double_operators.sql | 98 ++-- .../double/query_double_eq_functions.sql | 54 +- .../double/query_double_eq_operators.sql | 18 +- .../double/query_double_ord_functions.sql | 134 ++--- .../double/query_double_ord_ope_functions.sql | 134 ++--- .../double/query_double_ord_ope_operators.sql | 50 +- .../double/query_double_ord_operators.sql | 50 +- .../double/query_double_ord_ore_functions.sql | 134 ++--- .../double/query_double_ord_ore_operators.sql | 50 +- .../v3/scalars/double/query_double_types.sql | 44 +- .../scalars/integer/integer_eq_functions.sql | 504 ++++++++--------- .../scalars/integer/integer_eq_operators.sql | 190 +++---- .../v3/scalars/integer/integer_functions.sql | 504 ++++++++--------- .../v3/scalars/integer/integer_operators.sql | 190 +++---- .../integer/integer_ord_aggregates.sql | 54 +- .../scalars/integer/integer_ord_functions.sql | 480 ++++++++--------- .../integer/integer_ord_ope_aggregates.sql | 54 +- .../integer/integer_ord_ope_functions.sql | 480 ++++++++--------- .../integer/integer_ord_ope_operators.sql | 190 +++---- .../scalars/integer/integer_ord_operators.sql | 190 +++---- .../integer/integer_ord_ore_aggregates.sql | 54 +- .../integer/integer_ord_ore_functions.sql | 480 ++++++++--------- .../integer/integer_ord_ore_operators.sql | 190 +++---- .../src/v3/scalars/integer/integer_types.sql | 50 +- .../integer/json_entry_integer_functions.sql | 258 ++++----- .../integer/json_entry_integer_operators.sql | 98 ++-- .../integer/query_integer_eq_functions.sql | 54 +- .../integer/query_integer_eq_operators.sql | 18 +- .../integer/query_integer_ord_functions.sql | 134 ++--- .../query_integer_ord_ope_functions.sql | 134 ++--- .../query_integer_ord_ope_operators.sql | 50 +- .../integer/query_integer_ord_operators.sql | 50 +- .../query_integer_ord_ore_functions.sql | 134 ++--- .../query_integer_ord_ore_operators.sql | 50 +- .../scalars/integer/query_integer_types.sql | 44 +- .../src/v3/scalars/json/json_functions.sql | 504 ++++++++--------- .../src/v3/scalars/json/json_operators.sql | 190 +++---- .../eql/src/v3/scalars/json/json_types.sql | 10 +- .../numeric/json_entry_numeric_functions.sql | 258 ++++----- .../numeric/json_entry_numeric_operators.sql | 98 ++-- .../scalars/numeric/numeric_eq_functions.sql | 504 ++++++++--------- .../scalars/numeric/numeric_eq_operators.sql | 190 +++---- .../v3/scalars/numeric/numeric_functions.sql | 504 ++++++++--------- .../v3/scalars/numeric/numeric_operators.sql | 190 +++---- .../numeric/numeric_ord_aggregates.sql | 54 +- .../scalars/numeric/numeric_ord_functions.sql | 480 ++++++++--------- .../numeric/numeric_ord_ope_aggregates.sql | 54 +- .../numeric/numeric_ord_ope_functions.sql | 480 ++++++++--------- .../numeric/numeric_ord_ope_operators.sql | 190 +++---- .../scalars/numeric/numeric_ord_operators.sql | 190 +++---- .../numeric/numeric_ord_ore_aggregates.sql | 54 +- .../numeric/numeric_ord_ore_functions.sql | 480 ++++++++--------- .../numeric/numeric_ord_ore_operators.sql | 190 +++---- .../src/v3/scalars/numeric/numeric_types.sql | 50 +- .../numeric/query_numeric_eq_functions.sql | 54 +- .../numeric/query_numeric_eq_operators.sql | 18 +- .../numeric/query_numeric_ord_functions.sql | 134 ++--- .../query_numeric_ord_ope_functions.sql | 134 ++--- .../query_numeric_ord_ope_operators.sql | 50 +- .../numeric/query_numeric_ord_operators.sql | 50 +- .../query_numeric_ord_ore_functions.sql | 134 ++--- .../query_numeric_ord_ore_operators.sql | 50 +- .../scalars/numeric/query_numeric_types.sql | 44 +- packages/eql/src/v3/scalars/ore_fallback.sql | 88 +-- .../real/json_entry_real_functions.sql | 258 ++++----- .../real/json_entry_real_operators.sql | 98 ++-- .../scalars/real/query_real_eq_functions.sql | 54 +- .../scalars/real/query_real_eq_operators.sql | 18 +- .../scalars/real/query_real_ord_functions.sql | 134 ++--- .../real/query_real_ord_ope_functions.sql | 134 ++--- .../real/query_real_ord_ope_operators.sql | 50 +- .../scalars/real/query_real_ord_operators.sql | 50 +- .../real/query_real_ord_ore_functions.sql | 134 ++--- .../real/query_real_ord_ore_operators.sql | 50 +- .../src/v3/scalars/real/query_real_types.sql | 44 +- .../src/v3/scalars/real/real_eq_functions.sql | 504 ++++++++--------- .../src/v3/scalars/real/real_eq_operators.sql | 190 +++---- .../src/v3/scalars/real/real_functions.sql | 504 ++++++++--------- .../src/v3/scalars/real/real_operators.sql | 190 +++---- .../v3/scalars/real/real_ord_aggregates.sql | 54 +- .../v3/scalars/real/real_ord_functions.sql | 480 ++++++++--------- .../scalars/real/real_ord_ope_aggregates.sql | 54 +- .../scalars/real/real_ord_ope_functions.sql | 480 ++++++++--------- .../scalars/real/real_ord_ope_operators.sql | 190 +++---- .../v3/scalars/real/real_ord_operators.sql | 190 +++---- .../scalars/real/real_ord_ore_aggregates.sql | 54 +- .../scalars/real/real_ord_ore_functions.sql | 480 ++++++++--------- .../scalars/real/real_ord_ore_operators.sql | 190 +++---- .../eql/src/v3/scalars/real/real_types.sql | 50 +- .../json_entry_smallint_functions.sql | 258 ++++----- .../json_entry_smallint_operators.sql | 98 ++-- .../smallint/query_smallint_eq_functions.sql | 54 +- .../smallint/query_smallint_eq_operators.sql | 18 +- .../smallint/query_smallint_ord_functions.sql | 134 ++--- .../query_smallint_ord_ope_functions.sql | 134 ++--- .../query_smallint_ord_ope_operators.sql | 50 +- .../smallint/query_smallint_ord_operators.sql | 50 +- .../query_smallint_ord_ore_functions.sql | 134 ++--- .../query_smallint_ord_ore_operators.sql | 50 +- .../scalars/smallint/query_smallint_types.sql | 44 +- .../smallint/smallint_eq_functions.sql | 504 ++++++++--------- .../smallint/smallint_eq_operators.sql | 190 +++---- .../scalars/smallint/smallint_functions.sql | 504 ++++++++--------- .../scalars/smallint/smallint_operators.sql | 190 +++---- .../smallint/smallint_ord_aggregates.sql | 54 +- .../smallint/smallint_ord_functions.sql | 480 ++++++++--------- .../smallint/smallint_ord_ope_aggregates.sql | 54 +- .../smallint/smallint_ord_ope_functions.sql | 480 ++++++++--------- .../smallint/smallint_ord_ope_operators.sql | 190 +++---- .../smallint/smallint_ord_operators.sql | 190 +++---- .../smallint/smallint_ord_ore_aggregates.sql | 54 +- .../smallint/smallint_ord_ore_functions.sql | 480 ++++++++--------- .../smallint/smallint_ord_ore_operators.sql | 190 +++---- .../v3/scalars/smallint/smallint_types.sql | 50 +- .../text/json_entry_text_functions.sql | 402 +++++++------- .../text/json_entry_text_operators.sql | 146 ++--- .../scalars/text/query_text_eq_functions.sql | 54 +- .../scalars/text/query_text_eq_operators.sql | 18 +- .../text/query_text_match_functions.sql | 34 +- .../text/query_text_match_operators.sql | 10 +- .../scalars/text/query_text_ord_functions.sql | 146 ++--- .../text/query_text_ord_ope_functions.sql | 146 ++--- .../text/query_text_ord_ope_operators.sql | 50 +- .../scalars/text/query_text_ord_operators.sql | 50 +- .../text/query_text_ord_ore_functions.sql | 146 ++--- .../text/query_text_ord_ore_operators.sql | 50 +- .../text/query_text_search_functions.sql | 178 +++--- .../text/query_text_search_operators.sql | 58 +- .../text/query_text_search_ore_functions.sql | 178 +++--- .../text/query_text_search_ore_operators.sql | 58 +- .../src/v3/scalars/text/query_text_types.sql | 74 +-- .../src/v3/scalars/text/text_eq_functions.sql | 504 ++++++++--------- .../src/v3/scalars/text/text_eq_operators.sql | 190 +++---- .../src/v3/scalars/text/text_functions.sql | 504 ++++++++--------- .../v3/scalars/text/text_match_functions.sql | 510 +++++++++--------- .../v3/scalars/text/text_match_operators.sql | 190 +++---- .../src/v3/scalars/text/text_operators.sql | 190 +++---- .../v3/scalars/text/text_ord_aggregates.sql | 54 +- .../v3/scalars/text/text_ord_functions.sql | 492 ++++++++--------- .../scalars/text/text_ord_ope_aggregates.sql | 54 +- .../scalars/text/text_ord_ope_functions.sql | 492 ++++++++--------- .../scalars/text/text_ord_ope_operators.sql | 190 +++---- .../v3/scalars/text/text_ord_operators.sql | 190 +++---- .../scalars/text/text_ord_ore_aggregates.sql | 54 +- .../scalars/text/text_ord_ore_functions.sql | 492 ++++++++--------- .../scalars/text/text_ord_ore_operators.sql | 190 +++---- .../scalars/text/text_search_aggregates.sql | 54 +- .../v3/scalars/text/text_search_functions.sql | 498 ++++++++--------- .../v3/scalars/text/text_search_operators.sql | 190 +++---- .../text/text_search_ore_aggregates.sql | 54 +- .../text/text_search_ore_functions.sql | 498 ++++++++--------- .../text/text_search_ore_operators.sql | 190 +++---- .../eql/src/v3/scalars/text/text_types.sql | 80 +-- .../json_entry_timestamp_functions.sql | 290 +++++----- .../json_entry_timestamp_operators.sql | 98 ++-- .../query_timestamp_eq_functions.sql | 54 +- .../query_timestamp_eq_operators.sql | 18 +- .../query_timestamp_ord_functions.sql | 134 ++--- .../query_timestamp_ord_ope_functions.sql | 134 ++--- .../query_timestamp_ord_ope_operators.sql | 50 +- .../query_timestamp_ord_operators.sql | 50 +- .../query_timestamp_ord_ore_functions.sql | 134 ++--- .../query_timestamp_ord_ore_operators.sql | 50 +- .../timestamp/query_timestamp_types.sql | 44 +- .../timestamp/timestamp_eq_functions.sql | 504 ++++++++--------- .../timestamp/timestamp_eq_operators.sql | 190 +++---- .../scalars/timestamp/timestamp_functions.sql | 504 ++++++++--------- .../scalars/timestamp/timestamp_operators.sql | 190 +++---- .../timestamp/timestamp_ord_aggregates.sql | 54 +- .../timestamp/timestamp_ord_functions.sql | 480 ++++++++--------- .../timestamp_ord_ope_aggregates.sql | 54 +- .../timestamp/timestamp_ord_ope_functions.sql | 480 ++++++++--------- .../timestamp/timestamp_ord_ope_operators.sql | 190 +++---- .../timestamp/timestamp_ord_operators.sql | 190 +++---- .../timestamp_ord_ore_aggregates.sql | 54 +- .../timestamp/timestamp_ord_ore_functions.sql | 480 ++++++++--------- .../timestamp/timestamp_ord_ore_operators.sql | 190 +++---- .../v3/scalars/timestamp/timestamp_types.sql | 50 +- 246 files changed, 23145 insertions(+), 23145 deletions(-) diff --git a/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql index efa9f30f9..c28ef106c 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/bigint/bigint_eq_functions.sql ---! @brief Functions for public.eql_v3_bigint_eq. +--! @brief Functions for public.{{prefix}}_bigint_eq. ---! @brief Index extractor for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_bigint_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_bigint_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_bigint_eq) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_bigint_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. ---! @param a public.eql_v3_bigint_eq +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_bigint_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_bigint_eq) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_eq. +--! @brief Operator wrapper for public.{{prefix}}_bigint_eq. --! @param a jsonb ---! @param b public.eql_v3_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_bigint_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_bigint_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector text) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_eq, selector text) +RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_eq, selector integer) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_eq, selector integer) +RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_eq right operand of the blocked operator ---! @return public.eql_v3_bigint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_eq) -RETURNS public.eql_v3_bigint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_eq'; END; $$ +--! @param selector public.{{prefix}}_bigint_eq right operand of the blocked operator +--! @return public.{{prefix}}_bigint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_eq) +RETURNS public.{{prefix}}_bigint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql index 0bb312689..28b4f0c38 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_eq_functions.sql --! @file encrypted_domain/bigint/bigint_eq_operators.sql ---! @brief Operators for public.eql_v3_bigint_eq. +--! @brief Operators for public.{{prefix}}_bigint_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_eq ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_functions.sql index 1acd0d503..cc2debb8d 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/bigint/bigint_functions.sql ---! @brief Functions for public.eql_v3_bigint. +--! @brief Functions for public.{{prefix}}_bigint. ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector text) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint, selector text) +RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint, selector integer) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint, selector integer) +RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint right operand of the blocked operator ---! @return public.eql_v3_bigint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint) -RETURNS public.eql_v3_bigint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint'; END; $$ +--! @param selector public.{{prefix}}_bigint right operand of the blocked operator +--! @return public.{{prefix}}_bigint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint) +RETURNS public.{{prefix}}_bigint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint right operand of the blocked operator +--! @param selector public.{{prefix}}_bigint right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint, b public.{{prefix}}_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint left operand of the blocked operator +--! @param a public.{{prefix}}_bigint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint right operand of the blocked operator +--! @param b public.{{prefix}}_bigint right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/bigint/bigint_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_operators.sql index 46170b430..0e1a9e6af 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_functions.sql --! @file encrypted_domain/bigint/bigint_operators.sql ---! @brief Operators for public.eql_v3_bigint. +--! @brief Operators for public.{{prefix}}_bigint. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = public.{{prefix}}_bigint ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql index b4d508d87..eedcba3d8 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_operators.sql --! @file encrypted_domain/bigint/bigint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord. +--! @brief Aggregates for public.{{prefix}}_bigint_ord. ---! @brief State function for min on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @brief State function for min on public.{{prefix}}_bigint_ord. +--! @param state public.{{prefix}}_bigint_ord +--! @param value public.{{prefix}}_bigint_ord +--! @return public.{{prefix}}_bigint_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord, value public.{{prefix}}_bigint_ord) +RETURNS public.{{prefix}}_bigint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_bigint_ord. +--! @param input public.{{prefix}}_bigint_ord +--! @return public.{{prefix}}_bigint_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_bigint_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_bigint_ord. ---! @param state public.eql_v3_bigint_ord ---! @param value public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord, value public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord +--! @brief State function for max on public.{{prefix}}_bigint_ord. +--! @param state public.{{prefix}}_bigint_ord +--! @param value public.{{prefix}}_bigint_ord +--! @return public.{{prefix}}_bigint_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord, value public.{{prefix}}_bigint_ord) +RETURNS public.{{prefix}}_bigint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_bigint_ord. ---! @param input public.eql_v3_bigint_ord ---! @return public.eql_v3_bigint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_bigint_ord. +--! @param input public.{{prefix}}_bigint_ord +--! @return public.{{prefix}}_bigint_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_bigint_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql index 77acfe426..ad9b327d0 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/bigint/bigint_ord_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord. +--! @brief Functions for public.{{prefix}}_bigint_ord. ---! @brief Index extractor for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_bigint_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. ---! @param a public.eql_v3_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector text) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord, selector text) +RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord, selector integer) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord, selector integer) +RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord right operand of the blocked operator ---! @return public.eql_v3_bigint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord) -RETURNS public.eql_v3_bigint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord'; END; $$ +--! @param selector public.{{prefix}}_bigint_ord right operand of the blocked operator +--! @return public.{{prefix}}_bigint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord) +RETURNS public.{{prefix}}_bigint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql index 4e09605c1..58d86e1c6 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_operators.sql --! @file encrypted_domain/bigint/bigint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ope. +--! @brief Aggregates for public.{{prefix}}_bigint_ord_ope. ---! @brief State function for min on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope +--! @brief State function for min on public.{{prefix}}_bigint_ord_ope. +--! @param state public.{{prefix}}_bigint_ord_ope +--! @param value public.{{prefix}}_bigint_ord_ope +--! @return public.{{prefix}}_bigint_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord_ope, value public.{{prefix}}_bigint_ord_ope) +RETURNS public.{{prefix}}_bigint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_bigint_ord_ope. +--! @param input public.{{prefix}}_bigint_ord_ope +--! @return public.{{prefix}}_bigint_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_bigint_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_bigint_ord_ope. ---! @param state public.eql_v3_bigint_ord_ope ---! @param value public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ope, value public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope +--! @brief State function for max on public.{{prefix}}_bigint_ord_ope. +--! @param state public.{{prefix}}_bigint_ord_ope +--! @param value public.{{prefix}}_bigint_ord_ope +--! @return public.{{prefix}}_bigint_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord_ope, value public.{{prefix}}_bigint_ord_ope) +RETURNS public.{{prefix}}_bigint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_bigint_ord_ope. ---! @param input public.eql_v3_bigint_ord_ope ---! @return public.eql_v3_bigint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_bigint_ord_ope. +--! @param input public.{{prefix}}_bigint_ord_ope +--! @return public.{{prefix}}_bigint_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_bigint_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql index 478a60db1..70ef50924 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/bigint/bigint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ope. +--! @brief Functions for public.{{prefix}}_bigint_ord_ope. ---! @brief Index extractor for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_bigint_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_bigint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_bigint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_bigint_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_bigint_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector text) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ +--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ope, selector text) +RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ope, selector integer) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ +--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ope, selector integer) +RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ope) -RETURNS public.eql_v3_bigint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_bigint_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_bigint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord_ope) +RETURNS public.{{prefix}}_bigint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql index 65c515f20..32e990646 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_functions.sql --! @file encrypted_domain/bigint/bigint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ope. +--! @brief Operators for public.{{prefix}}_bigint_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ope ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql index c86e76306..9742bc09c 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_functions.sql --! @file encrypted_domain/bigint/bigint_ord_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord. +--! @brief Operators for public.{{prefix}}_bigint_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql index 685bc67a9..821641457 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_operators.sql --! @file encrypted_domain/bigint/bigint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_bigint_ord_ore. +--! @brief Aggregates for public.{{prefix}}_bigint_ord_ore. ---! @brief State function for min on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore +--! @brief State function for min on public.{{prefix}}_bigint_ord_ore. +--! @param state public.{{prefix}}_bigint_ord_ore +--! @param value public.{{prefix}}_bigint_ord_ore +--! @return public.{{prefix}}_bigint_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_bigint_ord_ore, value public.{{prefix}}_bigint_ord_ore) +RETURNS public.{{prefix}}_bigint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_bigint_ord_ore. +--! @param input public.{{prefix}}_bigint_ord_ore +--! @return public.{{prefix}}_bigint_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_bigint_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_bigint_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_bigint_ord_ore. ---! @param state public.eql_v3_bigint_ord_ore ---! @param value public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_bigint_ord_ore, value public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore +--! @brief State function for max on public.{{prefix}}_bigint_ord_ore. +--! @param state public.{{prefix}}_bigint_ord_ore +--! @param value public.{{prefix}}_bigint_ord_ore +--! @return public.{{prefix}}_bigint_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_bigint_ord_ore, value public.{{prefix}}_bigint_ord_ore) +RETURNS public.{{prefix}}_bigint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_bigint_ord_ore. ---! @param input public.eql_v3_bigint_ord_ore ---! @return public.eql_v3_bigint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_bigint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_bigint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_bigint_ord_ore. +--! @param input public.{{prefix}}_bigint_ord_ore +--! @return public.{{prefix}}_bigint_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_bigint_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_bigint_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql index 0441c8186..c2856dba4 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/bigint/bigint_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_bigint_ord_ore. +--! @brief Functions for public.{{prefix}}_bigint_ord_ore. ---! @brief Index extractor for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_bigint_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_bigint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_bigint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_bigint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_bigint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_bigint_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_bigint_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector text) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ore, selector text) +RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_bigint_ord_ore, selector integer) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_bigint_ord_ore, selector integer) +RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator ---! @return public.eql_v3_bigint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_bigint_ord_ore) -RETURNS public.eql_v3_bigint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_bigint_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_bigint_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_bigint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_bigint_ord_ore) +RETURNS public.{{prefix}}_bigint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_bigint_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_bigint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_bigint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_bigint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_bigint_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_bigint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_bigint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_bigint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_bigint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_bigint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_bigint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_bigint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_bigint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_bigint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_bigint_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_bigint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_bigint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_bigint_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql index 2f87146cc..3894c846f 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_functions.sql --! @file encrypted_domain/bigint/bigint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_bigint_ord_ore. +--! @brief Operators for public.{{prefix}}_bigint_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_bigint_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_bigint_ord_ore ); diff --git a/packages/eql/src/v3/scalars/bigint/bigint_types.sql b/packages/eql/src/v3/scalars/bigint/bigint_types.sql index 940c301f5..fd257d7f9 100644 --- a/packages/eql/src/v3/scalars/bigint/bigint_types.sql +++ b/packages/eql/src/v3/scalars/bigint/bigint_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_bigint. + --! @brief Encrypted domain public.{{prefix}}_bigint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_bigint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint AS jsonb + CREATE DOMAIN public.{{prefix}}_bigint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint IS 'EQL encrypted bigint (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_bigint IS 'EQL encrypted bigint (storage only)'; - --! @brief Encrypted domain public.eql_v3_bigint_eq. + --! @brief Encrypted domain public.{{prefix}}_bigint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_bigint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_bigint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_eq IS 'EQL encrypted bigint (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_bigint_eq IS 'EQL encrypted bigint (equality)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_bigint_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_bigint_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_bigint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_bigint_ord_ore IS 'EQL encrypted bigint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord. + --! @brief Encrypted domain public.{{prefix}}_bigint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_bigint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_bigint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_bigint_ord IS 'EQL encrypted bigint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_bigint_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_bigint_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_bigint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_bigint_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_bigint_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_bigint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_bigint_ord_ope IS 'EQL encrypted bigint (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql index 3ee50c424..da47e1897 100644 --- a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql --! @file encrypted_domain/bigint/json_entry_bigint_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_bigint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_bigint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_bigint_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_bigint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_bigint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_bigint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql index cc44db7ce..3403a3c1f 100644 --- a/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/json_entry_bigint_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/bigint/json_entry_bigint_functions.sql --! @file encrypted_domain/bigint/json_entry_bigint_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql index 7efa82837..7983a84ae 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_eq_functions.sql --! @file encrypted_domain/bigint/query_bigint_eq_functions.sql ---! @brief Functions for eql_v3.query_bigint_eq. +--! @brief Functions for {{prefix}}.query_bigint_eq. ---! @brief Index extractor for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_bigint_eq. +--! @param a {{prefix}}.query_bigint_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_bigint_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for {{prefix}}.query_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq +--! @param b {{prefix}}.query_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_eq, b {{prefix}}.query_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for {{prefix}}.query_bigint_eq. +--! @param a {{prefix}}.query_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a public.eql_v3_bigint_eq ---! @param b eql_v3.query_bigint_eq +--! @brief Operator wrapper for {{prefix}}.query_bigint_eq. +--! @param a public.{{prefix}}_bigint_eq +--! @param b {{prefix}}.query_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_eq, b eql_v3.query_bigint_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_eq, b {{prefix}}.query_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_eq. ---! @param a eql_v3.query_bigint_eq ---! @param b public.eql_v3_bigint_eq +--! @brief Operator wrapper for {{prefix}}.query_bigint_eq. +--! @param a {{prefix}}.query_bigint_eq +--! @param b public.{{prefix}}_bigint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.eql_v3_bigint_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_eq, b public.{{prefix}}_bigint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql index 76f9908ec..d726740a7 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/bigint/query_bigint_eq_functions.sql --! @file encrypted_domain/bigint/query_bigint_eq_operators.sql ---! @brief Operators for eql_v3.query_bigint_eq. +--! @brief Operators for {{prefix}}.query_bigint_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = {{prefix}}.query_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_eq, RIGHTARG = eql_v3.query_bigint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_eq, RIGHTARG = {{prefix}}.query_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.eql_v3_bigint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_bigint_eq, RIGHTARG = public.{{prefix}}_bigint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql index 4fbd3e16b..c85509ab2 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord. +--! @brief Functions for {{prefix}}.query_bigint_ord. ---! @brief Index extractor for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_bigint_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a public.eql_v3_bigint_ord ---! @param b eql_v3.query_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a public.{{prefix}}_bigint_ord +--! @param b {{prefix}}.query_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord, b eql_v3.query_bigint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord, b {{prefix}}.query_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord. ---! @param a eql_v3.query_bigint_ord ---! @param b public.eql_v3_bigint_ord +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord. +--! @param a {{prefix}}.query_bigint_ord +--! @param b public.{{prefix}}_bigint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_bigint_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord, b public.{{prefix}}_bigint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql index c28bec13a..6315451b9 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ope. +--! @brief Functions for {{prefix}}.query_bigint_ord_ope. ---! @brief Index extractor for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_bigint_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a public.eql_v3_bigint_ord_ope ---! @param b eql_v3.query_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a public.{{prefix}}_bigint_ord_ope +--! @param b {{prefix}}.query_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ope, b eql_v3.query_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ope, b {{prefix}}.query_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ope. ---! @param a eql_v3.query_bigint_ord_ope ---! @param b public.eql_v3_bigint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ope. +--! @param a {{prefix}}.query_bigint_ord_ope +--! @param b public.{{prefix}}_bigint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_bigint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ope, b public.{{prefix}}_bigint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql index 7e58ae385..2f01b668a 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ope. +--! @brief Operators for {{prefix}}.query_bigint_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ope, RIGHTARG = {{prefix}}.query_bigint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_bigint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_bigint_ord_ope, RIGHTARG = public.{{prefix}}_bigint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql index 9bbb5f8d0..42274269f 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord. +--! @brief Operators for {{prefix}}.query_bigint_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord, RIGHTARG = eql_v3.query_bigint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord, RIGHTARG = {{prefix}}.query_bigint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_bigint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_bigint_ord, RIGHTARG = public.{{prefix}}_bigint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql index 9b90cc642..c1dec7671 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_bigint_ord_ore. +--! @brief Functions for {{prefix}}.query_bigint_ord_ore. ---! @brief Index extractor for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_bigint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_bigint_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a public.eql_v3_bigint_ord_ore ---! @param b eql_v3.query_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a public.{{prefix}}_bigint_ord_ore +--! @param b {{prefix}}.query_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_bigint_ord_ore, b eql_v3.query_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_bigint_ord_ore, b {{prefix}}.query_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_bigint_ord_ore. ---! @param a eql_v3.query_bigint_ord_ore ---! @param b public.eql_v3_bigint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_bigint_ord_ore. +--! @param a {{prefix}}.query_bigint_ord_ore +--! @param b public.{{prefix}}_bigint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.eql_v3_bigint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_bigint_ord_ore, b public.{{prefix}}_bigint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql index d672cfe57..a86c28310 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql --! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_bigint_ord_ore. +--! @brief Operators for {{prefix}}.query_bigint_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_bigint_ord_ore, RIGHTARG = {{prefix}}.query_bigint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.eql_v3_bigint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_bigint_ord_ore, RIGHTARG = public.{{prefix}}_bigint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql b/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql index fbffb8c40..d1d4e14ed 100644 --- a/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql +++ b/packages/eql/src/v3/scalars/bigint/query_bigint_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/bigint/query_bigint_types.sql --! @brief Query-operand domains for bigint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_bigint_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_bigint_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_bigint_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_bigint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_bigint_eq IS 'EQL bigint query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_bigint_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_bigint_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_bigint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_bigint_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_bigint_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_bigint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_bigint_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_bigint_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_bigint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/boolean/boolean_functions.sql b/packages/eql/src/v3/scalars/boolean/boolean_functions.sql index c34730227..e3414420f 100644 --- a/packages/eql/src/v3/scalars/boolean/boolean_functions.sql +++ b/packages/eql/src/v3/scalars/boolean/boolean_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/boolean/boolean_functions.sql ---! @brief Functions for public.eql_v3_boolean. +--! @brief Functions for public.{{prefix}}_boolean. ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector text) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_boolean, selector text) +RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_boolean, selector integer) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_boolean, selector integer) +RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_boolean right operand of the blocked operator ---! @return public.eql_v3_boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_boolean) -RETURNS public.eql_v3_boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_boolean'; END; $$ +--! @param selector public.{{prefix}}_boolean right operand of the blocked operator +--! @return public.{{prefix}}_boolean never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_boolean) +RETURNS public.{{prefix}}_boolean IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_boolean, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_boolean, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_boolean, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_boolean right operand of the blocked operator +--! @param selector public.{{prefix}}_boolean right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_boolean) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_boolean, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_boolean, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_boolean, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_boolean, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_boolean) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_boolean, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_boolean, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_boolean, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_boolean, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_boolean, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_boolean, b public.{{prefix}}_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_boolean left operand of the blocked operator +--! @param a public.{{prefix}}_boolean left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_boolean, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_boolean, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_boolean. +--! @brief Unsupported operator blocker for public.{{prefix}}_boolean. --! ---! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_boolean and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_boolean right operand of the blocked operator +--! @param b public.{{prefix}}_boolean right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_boolean) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_boolean) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_boolean'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_boolean'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/boolean/boolean_operators.sql b/packages/eql/src/v3/scalars/boolean/boolean_operators.sql index 004793512..d7a3d00e4 100644 --- a/packages/eql/src/v3/scalars/boolean/boolean_operators.sql +++ b/packages/eql/src/v3/scalars/boolean/boolean_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/boolean/boolean_functions.sql --! @file encrypted_domain/boolean/boolean_operators.sql ---! @brief Operators for public.eql_v3_boolean. +--! @brief Operators for public.{{prefix}}_boolean. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_boolean, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = public.{{prefix}}_boolean ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_boolean, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_boolean, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_boolean + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_boolean ); diff --git a/packages/eql/src/v3/scalars/boolean/boolean_types.sql b/packages/eql/src/v3/scalars/boolean/boolean_types.sql index 755c68df4..217adc946 100644 --- a/packages/eql/src/v3/scalars/boolean/boolean_types.sql +++ b/packages/eql/src/v3/scalars/boolean/boolean_types.sql @@ -6,21 +6,21 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_boolean. + --! @brief Encrypted domain public.{{prefix}}_boolean. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_boolean' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_boolean' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_boolean AS jsonb + CREATE DOMAIN public.{{prefix}}_boolean AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_boolean IS 'EQL encrypted boolean (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_boolean IS 'EQL encrypted boolean (storage only)'; END $$; diff --git a/packages/eql/src/v3/scalars/date/date_eq_functions.sql b/packages/eql/src/v3/scalars/date/date_eq_functions.sql index c72d2b9d1..ca4cd6750 100644 --- a/packages/eql/src/v3/scalars/date/date_eq_functions.sql +++ b/packages/eql/src/v3/scalars/date/date_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/date/date_eq_functions.sql ---! @brief Functions for public.eql_v3_date_eq. +--! @brief Functions for public.{{prefix}}_date_eq. ---! @brief Index extractor for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_date_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_date_eq. +--! @param a public.{{prefix}}_date_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_date_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.{{prefix}}_date_eq. +--! @param a public.{{prefix}}_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.{{prefix}}_date_eq. +--! @param a public.{{prefix}}_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.{{prefix}}_date_eq. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_date_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for public.{{prefix}}_date_eq. +--! @param a public.{{prefix}}_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. ---! @param a public.eql_v3_date_eq +--! @brief Operator wrapper for public.{{prefix}}_date_eq. +--! @param a public.{{prefix}}_date_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_date_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_date_eq) $$; ---! @brief Operator wrapper for public.eql_v3_date_eq. +--! @brief Operator wrapper for public.{{prefix}}_date_eq. --! @param a jsonb ---! @param b public.eql_v3_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_date_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_date_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector text) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_eq, selector text) +RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_eq, selector integer) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_eq, selector integer) +RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_eq right operand of the blocked operator ---! @return public.eql_v3_date_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_eq) -RETURNS public.eql_v3_date_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_eq'; END; $$ +--! @param selector public.{{prefix}}_date_eq right operand of the blocked operator +--! @return public.{{prefix}}_date_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_eq) +RETURNS public.{{prefix}}_date_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_date_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_eq, b public.{{prefix}}_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_eq left operand of the blocked operator +--! @param a public.{{prefix}}_date_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_eq right operand of the blocked operator +--! @param b public.{{prefix}}_date_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/date_eq_operators.sql b/packages/eql/src/v3/scalars/date/date_eq_operators.sql index 6fa719cc4..17ec9d4a2 100644 --- a/packages/eql/src/v3/scalars/date/date_eq_operators.sql +++ b/packages/eql/src/v3/scalars/date/date_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/date/date_eq_functions.sql --! @file encrypted_domain/date/date_eq_operators.sql ---! @brief Operators for public.eql_v3_date_eq. +--! @brief Operators for public.{{prefix}}_date_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = public.{{prefix}}_date_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_eq ); diff --git a/packages/eql/src/v3/scalars/date/date_functions.sql b/packages/eql/src/v3/scalars/date/date_functions.sql index 463bbdca5..0ac101353 100644 --- a/packages/eql/src/v3/scalars/date/date_functions.sql +++ b/packages/eql/src/v3/scalars/date/date_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/date/date_functions.sql ---! @brief Functions for public.eql_v3_date. +--! @brief Functions for public.{{prefix}}_date. ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_date never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector text) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date, selector text) +RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_date never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date, selector integer) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date, selector integer) +RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date right operand of the blocked operator ---! @return public.eql_v3_date never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date) -RETURNS public.eql_v3_date IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date'; END; $$ +--! @param selector public.{{prefix}}_date right operand of the blocked operator +--! @return public.{{prefix}}_date never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date) +RETURNS public.{{prefix}}_date IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date right operand of the blocked operator +--! @param selector public.{{prefix}}_date right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date, b public.{{prefix}}_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date left operand of the blocked operator +--! @param a public.{{prefix}}_date left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date. +--! @brief Unsupported operator blocker for public.{{prefix}}_date. --! ---! Intercepts an operator that is not supported on public.eql_v3_date and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date right operand of the blocked operator +--! @param b public.{{prefix}}_date right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/date_operators.sql b/packages/eql/src/v3/scalars/date/date_operators.sql index daad33efe..bc651c657 100644 --- a/packages/eql/src/v3/scalars/date/date_operators.sql +++ b/packages/eql/src/v3/scalars/date/date_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/date/date_functions.sql --! @file encrypted_domain/date/date_operators.sql ---! @brief Operators for public.eql_v3_date. +--! @brief Operators for public.{{prefix}}_date. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_date, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date, RIGHTARG = public.{{prefix}}_date ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql index c3050d373..17fc17831 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/date/date_ord_operators.sql --! @file encrypted_domain/date/date_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord. +--! @brief Aggregates for public.{{prefix}}_date_ord. ---! @brief State function for min on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for min on public.{{prefix}}_date_ord. +--! @param state public.{{prefix}}_date_ord +--! @param value public.{{prefix}}_date_ord +--! @return public.{{prefix}}_date_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord, value public.{{prefix}}_date_ord) +RETURNS public.{{prefix}}_date_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_date_ord. +--! @param input public.{{prefix}}_date_ord +--! @return public.{{prefix}}_date_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_date_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_date_ord. ---! @param state public.eql_v3_date_ord ---! @param value public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord, value public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord +--! @brief State function for max on public.{{prefix}}_date_ord. +--! @param state public.{{prefix}}_date_ord +--! @param value public.{{prefix}}_date_ord +--! @return public.{{prefix}}_date_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord, value public.{{prefix}}_date_ord) +RETURNS public.{{prefix}}_date_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_date_ord. ---! @param input public.eql_v3_date_ord ---! @return public.eql_v3_date_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_date_ord. +--! @param input public.{{prefix}}_date_ord +--! @return public.{{prefix}}_date_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_date_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_functions.sql index baf000ced..859031af8 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_functions.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/date/date_ord_functions.sql ---! @brief Functions for public.eql_v3_date_ord. +--! @brief Functions for public.{{prefix}}_date_ord. ---! @brief Index extractor for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_date_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. ---! @param a public.eql_v3_date_ord +--! @brief Operator wrapper for public.{{prefix}}_date_ord. +--! @param a public.{{prefix}}_date_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord. +--! @brief Operator wrapper for public.{{prefix}}_date_ord. --! @param a jsonb ---! @param b public.eql_v3_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector text) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord, selector text) +RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord, selector integer) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord, selector integer) +RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord right operand of the blocked operator ---! @return public.eql_v3_date_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord) -RETURNS public.eql_v3_date_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord'; END; $$ +--! @param selector public.{{prefix}}_date_ord right operand of the blocked operator +--! @return public.{{prefix}}_date_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord) +RETURNS public.{{prefix}}_date_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_date_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord, b public.{{prefix}}_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql index 7f2908c0c..26fa57f22 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ope_operators.sql --! @file encrypted_domain/date/date_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ope. +--! @brief Aggregates for public.{{prefix}}_date_ord_ope. ---! @brief State function for min on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope +--! @brief State function for min on public.{{prefix}}_date_ord_ope. +--! @param state public.{{prefix}}_date_ord_ope +--! @param value public.{{prefix}}_date_ord_ope +--! @return public.{{prefix}}_date_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord_ope, value public.{{prefix}}_date_ord_ope) +RETURNS public.{{prefix}}_date_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_date_ord_ope. +--! @param input public.{{prefix}}_date_ord_ope +--! @return public.{{prefix}}_date_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_date_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_date_ord_ope. ---! @param state public.eql_v3_date_ord_ope ---! @param value public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ope, value public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope +--! @brief State function for max on public.{{prefix}}_date_ord_ope. +--! @param state public.{{prefix}}_date_ord_ope +--! @param value public.{{prefix}}_date_ord_ope +--! @return public.{{prefix}}_date_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord_ope, value public.{{prefix}}_date_ord_ope) +RETURNS public.{{prefix}}_date_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_date_ord_ope. ---! @param input public.eql_v3_date_ord_ope ---! @return public.eql_v3_date_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_date_ord_ope. +--! @param input public.{{prefix}}_date_ord_ope +--! @return public.{{prefix}}_date_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_date_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql index 9cc2a88d0..c64f82300 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/date/date_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ope. +--! @brief Functions for public.{{prefix}}_date_ord_ope. ---! @brief Index extractor for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_date_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_date_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_date_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_date_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_date_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_date_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector text) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ope, selector text) +RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ope, selector integer) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ope, selector integer) +RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator ---! @return public.eql_v3_date_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ope) -RETURNS public.eql_v3_date_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_date_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_date_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord_ope) +RETURNS public.{{prefix}}_date_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql index b511e73a0..6a5ce6b96 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ope_functions.sql --! @file encrypted_domain/date/date_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ope. +--! @brief Operators for public.{{prefix}}_date_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ope ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_operators.sql index 28e0bac49..bed1b234d 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_operators.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/date/date_ord_functions.sql --! @file encrypted_domain/date/date_ord_operators.sql ---! @brief Operators for public.eql_v3_date_ord. +--! @brief Operators for public.{{prefix}}_date_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = public.{{prefix}}_date_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql index bcc6aa22b..1cbcd8125 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ore_operators.sql --! @file encrypted_domain/date/date_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_date_ord_ore. +--! @brief Aggregates for public.{{prefix}}_date_ord_ore. ---! @brief State function for min on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore +--! @brief State function for min on public.{{prefix}}_date_ord_ore. +--! @param state public.{{prefix}}_date_ord_ore +--! @param value public.{{prefix}}_date_ord_ore +--! @return public.{{prefix}}_date_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_date_ord_ore, value public.{{prefix}}_date_ord_ore) +RETURNS public.{{prefix}}_date_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_date_ord_ore. +--! @param input public.{{prefix}}_date_ord_ore +--! @return public.{{prefix}}_date_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_date_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_date_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_date_ord_ore. ---! @param state public.eql_v3_date_ord_ore ---! @param value public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_date_ord_ore, value public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore +--! @brief State function for max on public.{{prefix}}_date_ord_ore. +--! @param state public.{{prefix}}_date_ord_ore +--! @param value public.{{prefix}}_date_ord_ore +--! @return public.{{prefix}}_date_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_date_ord_ore, value public.{{prefix}}_date_ord_ore) +RETURNS public.{{prefix}}_date_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_date_ord_ore. ---! @param input public.eql_v3_date_ord_ore ---! @return public.eql_v3_date_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_date_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_date_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_date_ord_ore. +--! @param input public.{{prefix}}_date_ord_ore +--! @return public.{{prefix}}_date_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_date_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_date_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql index a84903fb3..676c12d33 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/date/date_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_date_ord_ore. +--! @brief Functions for public.{{prefix}}_date_ord_ore. ---! @brief Index extractor for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_date_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_date_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_date_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_date_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_date_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_date_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_date_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector text) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ore, selector text) +RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_date_ord_ore, selector integer) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_date_ord_ore, selector integer) +RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator ---! @return public.eql_v3_date_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_date_ord_ore) -RETURNS public.eql_v3_date_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_date_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_date_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_date_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_date_ord_ore) +RETURNS public.{{prefix}}_date_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_date_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_date_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_date_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_date_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_date_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_date_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_date_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_date_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_date_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_date_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_date_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_date_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_date_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_date_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_date_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_date_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_date_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_date_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_date_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_date_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql b/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql index 28a9cc7ed..a248fbfc1 100644 --- a/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/date/date_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ore_functions.sql --! @file encrypted_domain/date/date_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_date_ord_ore. +--! @brief Operators for public.{{prefix}}_date_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_date_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_date_ord_ore ); diff --git a/packages/eql/src/v3/scalars/date/date_types.sql b/packages/eql/src/v3/scalars/date/date_types.sql index 88675a024..8ad3cb4ba 100644 --- a/packages/eql/src/v3/scalars/date/date_types.sql +++ b/packages/eql/src/v3/scalars/date/date_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_date. + --! @brief Encrypted domain public.{{prefix}}_date. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_date' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date AS jsonb + CREATE DOMAIN public.{{prefix}}_date AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date IS 'EQL encrypted date (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_date IS 'EQL encrypted date (storage only)'; - --! @brief Encrypted domain public.eql_v3_date_eq. + --! @brief Encrypted domain public.{{prefix}}_date_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_date_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_date_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_eq IS 'EQL encrypted date (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_date_eq IS 'EQL encrypted date (equality)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_date_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_date_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_date_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_date_ord_ore IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_date_ord. + --! @brief Encrypted domain public.{{prefix}}_date_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_date_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_date_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_date_ord IS 'EQL encrypted date (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_date_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_date_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_date_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_date_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_date_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_date_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_date_ord_ope IS 'EQL encrypted date (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql b/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql index afbaad93e..9e9f91635 100644 --- a/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql +++ b/packages/eql/src/v3/scalars/date/json_entry_date_functions.sql @@ -5,340 +5,340 @@ -- REQUIRE: src/v3/scalars/date/query_date_types.sql --! @file encrypted_domain/date/json_entry_date_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_date_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_date_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_date_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_date_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_date_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_date_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql b/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql index 21d15ef62..70cbcf9c8 100644 --- a/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql +++ b/packages/eql/src/v3/scalars/date/json_entry_date_operators.sql @@ -5,124 +5,124 @@ -- REQUIRE: src/v3/scalars/date/json_entry_date_functions.sql --! @file encrypted_domain/date/json_entry_date_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_date_ord_ope ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); diff --git a/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql b/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql index ca139e143..11dc75212 100644 --- a/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql +++ b/packages/eql/src/v3/scalars/date/query_date_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/date/date_eq_functions.sql --! @file encrypted_domain/date/query_date_eq_functions.sql ---! @brief Functions for eql_v3.query_date_eq. +--! @brief Functions for {{prefix}}.query_date_eq. ---! @brief Index extractor for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_date_eq. +--! @param a {{prefix}}.query_date_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_date_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq +--! @brief Operator wrapper for {{prefix}}.query_date_eq. +--! @param a public.{{prefix}}_date_eq +--! @param b {{prefix}}.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_eq, b {{prefix}}.query_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for {{prefix}}.query_date_eq. +--! @param a {{prefix}}.query_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a public.eql_v3_date_eq ---! @param b eql_v3.query_date_eq +--! @brief Operator wrapper for {{prefix}}.query_date_eq. +--! @param a public.{{prefix}}_date_eq +--! @param b {{prefix}}.query_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_eq, b eql_v3.query_date_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_eq, b {{prefix}}.query_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_eq. ---! @param a eql_v3.query_date_eq ---! @param b public.eql_v3_date_eq +--! @brief Operator wrapper for {{prefix}}.query_date_eq. +--! @param a {{prefix}}.query_date_eq +--! @param b public.{{prefix}}_date_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.eql_v3_date_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_eq, b public.{{prefix}}_date_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql b/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql index 9fe762f09..fac95ee10 100644 --- a/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql +++ b/packages/eql/src/v3/scalars/date/query_date_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/date/query_date_eq_functions.sql --! @file encrypted_domain/date/query_date_eq_operators.sql ---! @brief Operators for eql_v3.query_date_eq. +--! @brief Operators for {{prefix}}.query_date_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = {{prefix}}.query_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_date_eq, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_eq, RIGHTARG = eql_v3.query_date_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_eq, RIGHTARG = {{prefix}}.query_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.eql_v3_date_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_date_eq, RIGHTARG = public.{{prefix}}_date_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql index ca717c325..856f51cea 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/date/date_ord_functions.sql --! @file encrypted_domain/date/query_date_ord_functions.sql ---! @brief Functions for eql_v3.query_date_ord. +--! @brief Functions for {{prefix}}.query_date_ord. ---! @brief Index extractor for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_date_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a public.eql_v3_date_ord ---! @param b eql_v3.query_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a public.{{prefix}}_date_ord +--! @param b {{prefix}}.query_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord, b eql_v3.query_date_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord, b {{prefix}}.query_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord. ---! @param a eql_v3.query_date_ord ---! @param b public.eql_v3_date_ord +--! @brief Operator wrapper for {{prefix}}.query_date_ord. +--! @param a {{prefix}}.query_date_ord +--! @param b public.{{prefix}}_date_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.eql_v3_date_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord, b public.{{prefix}}_date_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql index 12c031721..f8c65dff7 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ope_functions.sql --! @file encrypted_domain/date/query_date_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_date_ord_ope. +--! @brief Functions for {{prefix}}.query_date_ord_ope. ---! @brief Index extractor for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_date_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a public.eql_v3_date_ord_ope ---! @param b eql_v3.query_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a public.{{prefix}}_date_ord_ope +--! @param b {{prefix}}.query_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ope, b eql_v3.query_date_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ope, b {{prefix}}.query_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ope. ---! @param a eql_v3.query_date_ord_ope ---! @param b public.eql_v3_date_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ope. +--! @param a {{prefix}}.query_date_ord_ope +--! @param b public.{{prefix}}_date_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_date_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord_ope, b public.{{prefix}}_date_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql index 02b85da2b..c1de6b14c 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/date/query_date_ord_ope_functions.sql --! @file encrypted_domain/date/query_date_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ope. +--! @brief Operators for {{prefix}}.query_date_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ope, RIGHTARG = {{prefix}}.query_date_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_date_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_date_ord_ope, RIGHTARG = public.{{prefix}}_date_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql index 94d0cdf44..c555e1b20 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/date/query_date_ord_functions.sql --! @file encrypted_domain/date/query_date_ord_operators.sql ---! @brief Operators for eql_v3.query_date_ord. +--! @brief Operators for {{prefix}}.query_date_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord, RIGHTARG = eql_v3.query_date_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord, RIGHTARG = {{prefix}}.query_date_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_date_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_date_ord, RIGHTARG = public.{{prefix}}_date_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql index d2a155a4f..c06aebf87 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/date/date_ord_ore_functions.sql --! @file encrypted_domain/date/query_date_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_date_ord_ore. +--! @brief Functions for {{prefix}}.query_date_ord_ore. ---! @brief Index extractor for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_date_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_date_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a public.eql_v3_date_ord_ore ---! @param b eql_v3.query_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a public.{{prefix}}_date_ord_ore +--! @param b {{prefix}}.query_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_date_ord_ore, b eql_v3.query_date_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_date_ord_ore, b {{prefix}}.query_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_date_ord_ore. ---! @param a eql_v3.query_date_ord_ore ---! @param b public.eql_v3_date_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_date_ord_ore. +--! @param a {{prefix}}.query_date_ord_ore +--! @param b public.{{prefix}}_date_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.eql_v3_date_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_date_ord_ore, b public.{{prefix}}_date_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql b/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql index 06b065845..4e22bab87 100644 --- a/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/date/query_date_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/date/query_date_ord_ore_functions.sql --! @file encrypted_domain/date/query_date_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_date_ord_ore. +--! @brief Operators for {{prefix}}.query_date_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_date_ord_ore, RIGHTARG = {{prefix}}.query_date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.eql_v3_date_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_date_ord_ore, RIGHTARG = public.{{prefix}}_date_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/date/query_date_types.sql b/packages/eql/src/v3/scalars/date/query_date_types.sql index 68b3bae1d..1f2f4edbf 100644 --- a/packages/eql/src/v3/scalars/date/query_date_types.sql +++ b/packages/eql/src/v3/scalars/date/query_date_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/date/query_date_types.sql --! @brief Query-operand domains for date (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_date_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_date_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_date_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_date_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_date_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_date_eq IS 'EQL date query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_date_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_date_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_date_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_date_ord_ore IS 'EQL date query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_date_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_date_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_date_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_date_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_date_ord IS 'EQL date query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_date_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_date_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_date_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_date_ord_ope IS 'EQL date query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/double/double_eq_functions.sql b/packages/eql/src/v3/scalars/double/double_eq_functions.sql index 49b33c2f6..597bb5b4e 100644 --- a/packages/eql/src/v3/scalars/double/double_eq_functions.sql +++ b/packages/eql/src/v3/scalars/double/double_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/double/double_eq_functions.sql ---! @brief Functions for public.eql_v3_double_eq. +--! @brief Functions for public.{{prefix}}_double_eq. ---! @brief Index extractor for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_double_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_double_eq. +--! @param a public.{{prefix}}_double_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_double_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for public.{{prefix}}_double_eq. +--! @param a public.{{prefix}}_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq +--! @brief Operator wrapper for public.{{prefix}}_double_eq. +--! @param a public.{{prefix}}_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_double_eq) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. +--! @brief Operator wrapper for public.{{prefix}}_double_eq. --! @param a jsonb ---! @param b public.eql_v3_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_double_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for public.{{prefix}}_double_eq. +--! @param a public.{{prefix}}_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. ---! @param a public.eql_v3_double_eq +--! @brief Operator wrapper for public.{{prefix}}_double_eq. +--! @param a public.{{prefix}}_double_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_double_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_double_eq) $$; ---! @brief Operator wrapper for public.eql_v3_double_eq. +--! @brief Operator wrapper for public.{{prefix}}_double_eq. --! @param a jsonb ---! @param b public.eql_v3_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_double_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_double_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector text) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_eq, selector text) +RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_eq, selector integer) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_eq, selector integer) +RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_eq right operand of the blocked operator ---! @return public.eql_v3_double_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_eq) -RETURNS public.eql_v3_double_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_eq'; END; $$ +--! @param selector public.{{prefix}}_double_eq right operand of the blocked operator +--! @return public.{{prefix}}_double_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_eq) +RETURNS public.{{prefix}}_double_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_double_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_eq, b public.{{prefix}}_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_eq left operand of the blocked operator +--! @param a public.{{prefix}}_double_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_eq right operand of the blocked operator +--! @param b public.{{prefix}}_double_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/double/double_eq_operators.sql b/packages/eql/src/v3/scalars/double/double_eq_operators.sql index 46d0ae5e6..131bc0ab4 100644 --- a/packages/eql/src/v3/scalars/double/double_eq_operators.sql +++ b/packages/eql/src/v3/scalars/double/double_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/double/double_eq_functions.sql --! @file encrypted_domain/double/double_eq_operators.sql ---! @brief Operators for public.eql_v3_double_eq. +--! @brief Operators for public.{{prefix}}_double_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = public.{{prefix}}_double_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_eq ); diff --git a/packages/eql/src/v3/scalars/double/double_functions.sql b/packages/eql/src/v3/scalars/double/double_functions.sql index 80a425549..ea3964722 100644 --- a/packages/eql/src/v3/scalars/double/double_functions.sql +++ b/packages/eql/src/v3/scalars/double/double_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/double/double_functions.sql ---! @brief Functions for public.eql_v3_double. +--! @brief Functions for public.{{prefix}}_double. ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_double never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector text) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double, selector text) +RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_double never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double, selector integer) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double, selector integer) +RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double right operand of the blocked operator ---! @return public.eql_v3_double never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double) -RETURNS public.eql_v3_double IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double'; END; $$ +--! @param selector public.{{prefix}}_double right operand of the blocked operator +--! @return public.{{prefix}}_double never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double) +RETURNS public.{{prefix}}_double IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double right operand of the blocked operator +--! @param selector public.{{prefix}}_double right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double, b public.{{prefix}}_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double left operand of the blocked operator +--! @param a public.{{prefix}}_double left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double. +--! @brief Unsupported operator blocker for public.{{prefix}}_double. --! ---! Intercepts an operator that is not supported on public.eql_v3_double and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double right operand of the blocked operator +--! @param b public.{{prefix}}_double right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/double/double_operators.sql b/packages/eql/src/v3/scalars/double/double_operators.sql index 4e8da085a..84a00a710 100644 --- a/packages/eql/src/v3/scalars/double/double_operators.sql +++ b/packages/eql/src/v3/scalars/double/double_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/double/double_functions.sql --! @file encrypted_domain/double/double_operators.sql ---! @brief Operators for public.eql_v3_double. +--! @brief Operators for public.{{prefix}}_double. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_double, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double, RIGHTARG = public.{{prefix}}_double ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql index 3314ab536..d7b1b04cf 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/double/double_ord_operators.sql --! @file encrypted_domain/double/double_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord. +--! @brief Aggregates for public.{{prefix}}_double_ord. ---! @brief State function for min on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord +--! @brief State function for min on public.{{prefix}}_double_ord. +--! @param state public.{{prefix}}_double_ord +--! @param value public.{{prefix}}_double_ord +--! @return public.{{prefix}}_double_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord, value public.{{prefix}}_double_ord) +RETURNS public.{{prefix}}_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_double_ord. +--! @param input public.{{prefix}}_double_ord +--! @return public.{{prefix}}_double_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_double_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_double_ord. ---! @param state public.eql_v3_double_ord ---! @param value public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord, value public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord +--! @brief State function for max on public.{{prefix}}_double_ord. +--! @param state public.{{prefix}}_double_ord +--! @param value public.{{prefix}}_double_ord +--! @return public.{{prefix}}_double_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord, value public.{{prefix}}_double_ord) +RETURNS public.{{prefix}}_double_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_double_ord. ---! @param input public.eql_v3_double_ord ---! @return public.eql_v3_double_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_double_ord. +--! @param input public.{{prefix}}_double_ord +--! @return public.{{prefix}}_double_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_double_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_functions.sql index 2554ce56c..c599d065e 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_functions.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/double/double_ord_functions.sql ---! @brief Functions for public.eql_v3_double_ord. +--! @brief Functions for public.{{prefix}}_double_ord. ---! @brief Index extractor for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_double_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. ---! @param a public.eql_v3_double_ord +--! @brief Operator wrapper for public.{{prefix}}_double_ord. +--! @param a public.{{prefix}}_double_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord. +--! @brief Operator wrapper for public.{{prefix}}_double_ord. --! @param a jsonb ---! @param b public.eql_v3_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector text) -RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord, selector text) +RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord, selector integer) -RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord, selector integer) +RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord right operand of the blocked operator ---! @return public.eql_v3_double_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord) -RETURNS public.eql_v3_double_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord'; END; $$ +--! @param selector public.{{prefix}}_double_ord right operand of the blocked operator +--! @return public.{{prefix}}_double_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord) +RETURNS public.{{prefix}}_double_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_double_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord, b public.{{prefix}}_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql index c9d8fddb5..8be554877 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ope_operators.sql --! @file encrypted_domain/double/double_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ope. +--! @brief Aggregates for public.{{prefix}}_double_ord_ope. ---! @brief State function for min on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for min on public.{{prefix}}_double_ord_ope. +--! @param state public.{{prefix}}_double_ord_ope +--! @param value public.{{prefix}}_double_ord_ope +--! @return public.{{prefix}}_double_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord_ope, value public.{{prefix}}_double_ord_ope) +RETURNS public.{{prefix}}_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_double_ord_ope. +--! @param input public.{{prefix}}_double_ord_ope +--! @return public.{{prefix}}_double_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_double_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_double_ord_ope. ---! @param state public.eql_v3_double_ord_ope ---! @param value public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ope, value public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope +--! @brief State function for max on public.{{prefix}}_double_ord_ope. +--! @param state public.{{prefix}}_double_ord_ope +--! @param value public.{{prefix}}_double_ord_ope +--! @return public.{{prefix}}_double_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord_ope, value public.{{prefix}}_double_ord_ope) +RETURNS public.{{prefix}}_double_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_double_ord_ope. ---! @param input public.eql_v3_double_ord_ope ---! @return public.eql_v3_double_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_double_ord_ope. +--! @param input public.{{prefix}}_double_ord_ope +--! @return public.{{prefix}}_double_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_double_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql index b3862e5e4..62ae689f7 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/double/double_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_double_ord_ope. +--! @brief Functions for public.{{prefix}}_double_ord_ope. ---! @brief Index extractor for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_double_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_double_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_double_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_double_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_double_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_double_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector text) -RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ope, selector text) +RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ope, selector integer) -RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ope, selector integer) +RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator ---! @return public.eql_v3_double_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ope) -RETURNS public.eql_v3_double_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_double_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_double_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord_ope) +RETURNS public.{{prefix}}_double_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql index e62acca0e..98a5eb75a 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ope_functions.sql --! @file encrypted_domain/double/double_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ope. +--! @brief Operators for public.{{prefix}}_double_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ope ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_operators.sql index 6178c72f9..c12695ffc 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_operators.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/double/double_ord_functions.sql --! @file encrypted_domain/double/double_ord_operators.sql ---! @brief Operators for public.eql_v3_double_ord. +--! @brief Operators for public.{{prefix}}_double_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = public.{{prefix}}_double_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql index 19c60c2fd..cdf731006 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ore_operators.sql --! @file encrypted_domain/double/double_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_double_ord_ore. +--! @brief Aggregates for public.{{prefix}}_double_ord_ore. ---! @brief State function for min on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore +--! @brief State function for min on public.{{prefix}}_double_ord_ore. +--! @param state public.{{prefix}}_double_ord_ore +--! @param value public.{{prefix}}_double_ord_ore +--! @return public.{{prefix}}_double_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_double_ord_ore, value public.{{prefix}}_double_ord_ore) +RETURNS public.{{prefix}}_double_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_double_ord_ore. +--! @param input public.{{prefix}}_double_ord_ore +--! @return public.{{prefix}}_double_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_double_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_double_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_double_ord_ore. ---! @param state public.eql_v3_double_ord_ore ---! @param value public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_double_ord_ore, value public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore +--! @brief State function for max on public.{{prefix}}_double_ord_ore. +--! @param state public.{{prefix}}_double_ord_ore +--! @param value public.{{prefix}}_double_ord_ore +--! @return public.{{prefix}}_double_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_double_ord_ore, value public.{{prefix}}_double_ord_ore) +RETURNS public.{{prefix}}_double_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_double_ord_ore. ---! @param input public.eql_v3_double_ord_ore ---! @return public.eql_v3_double_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_double_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_double_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_double_ord_ore. +--! @param input public.{{prefix}}_double_ord_ore +--! @return public.{{prefix}}_double_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_double_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_double_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql index 9c65feb22..8cdec0b7f 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/double/double_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_double_ord_ore. +--! @brief Functions for public.{{prefix}}_double_ord_ore. ---! @brief Index extractor for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_double_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_double_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_double_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_double_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_double_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_double_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_double_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector text) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ore, selector text) +RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_double_ord_ore, selector integer) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_double_ord_ore, selector integer) +RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator ---! @return public.eql_v3_double_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_double_ord_ore) -RETURNS public.eql_v3_double_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_double_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_double_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_double_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_double_ord_ore) +RETURNS public.{{prefix}}_double_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_double_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_double_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_double_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_double_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_double_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_double_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_double_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_double_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_double_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_double_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_double_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_double_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_double_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_double_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_double_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_double_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_double_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_double_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_double_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_double_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql b/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql index 6057dbbe7..7928b366f 100644 --- a/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/double/double_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ore_functions.sql --! @file encrypted_domain/double/double_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_double_ord_ore. +--! @brief Operators for public.{{prefix}}_double_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_double_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_double_ord_ore ); diff --git a/packages/eql/src/v3/scalars/double/double_types.sql b/packages/eql/src/v3/scalars/double/double_types.sql index b76cf46b4..95c4c3d85 100644 --- a/packages/eql/src/v3/scalars/double/double_types.sql +++ b/packages/eql/src/v3/scalars/double/double_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_double. + --! @brief Encrypted domain public.{{prefix}}_double. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_double' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double AS jsonb + CREATE DOMAIN public.{{prefix}}_double AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_double IS 'EQL encrypted double (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_double IS 'EQL encrypted double (storage only)'; - --! @brief Encrypted domain public.eql_v3_double_eq. + --! @brief Encrypted domain public.{{prefix}}_double_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_double_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_eq IS 'EQL encrypted double (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_double_eq IS 'EQL encrypted double (equality)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_double_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_double_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_double_ord_ore IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord. + --! @brief Encrypted domain public.{{prefix}}_double_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_double_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_double_ord IS 'EQL encrypted double (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_double_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_double_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_double_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_double_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_double_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_double_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_double_ord_ope IS 'EQL encrypted double (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql b/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql index 14d8b0d1d..ef2171dd9 100644 --- a/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql +++ b/packages/eql/src/v3/scalars/double/json_entry_double_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/double/query_double_ord_ope_functions.sql --! @file encrypted_domain/double/json_entry_double_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_double_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_double_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_double_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_double_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_double_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_double_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_double_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_double_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_double_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql b/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql index 8ff3727dc..391e2743e 100644 --- a/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql +++ b/packages/eql/src/v3/scalars/double/json_entry_double_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/double/json_entry_double_functions.sql --! @file encrypted_domain/double/json_entry_double_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql b/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql index 8c1c96076..814bf588e 100644 --- a/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql +++ b/packages/eql/src/v3/scalars/double/query_double_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/double/double_eq_functions.sql --! @file encrypted_domain/double/query_double_eq_functions.sql ---! @brief Functions for eql_v3.query_double_eq. +--! @brief Functions for {{prefix}}.query_double_eq. ---! @brief Index extractor for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_double_eq. +--! @param a {{prefix}}.query_double_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_double_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for {{prefix}}.query_double_eq. +--! @param a public.{{prefix}}_double_eq +--! @param b {{prefix}}.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_eq, b {{prefix}}.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for {{prefix}}.query_double_eq. +--! @param a {{prefix}}.query_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a public.eql_v3_double_eq ---! @param b eql_v3.query_double_eq +--! @brief Operator wrapper for {{prefix}}.query_double_eq. +--! @param a public.{{prefix}}_double_eq +--! @param b {{prefix}}.query_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_eq, b eql_v3.query_double_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_eq, b {{prefix}}.query_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_eq. ---! @param a eql_v3.query_double_eq ---! @param b public.eql_v3_double_eq +--! @brief Operator wrapper for {{prefix}}.query_double_eq. +--! @param a {{prefix}}.query_double_eq +--! @param b public.{{prefix}}_double_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.eql_v3_double_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_eq, b public.{{prefix}}_double_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql b/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql index d7649b103..f6294d8d4 100644 --- a/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql +++ b/packages/eql/src/v3/scalars/double/query_double_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/double/query_double_eq_functions.sql --! @file encrypted_domain/double/query_double_eq_operators.sql ---! @brief Operators for eql_v3.query_double_eq. +--! @brief Operators for {{prefix}}.query_double_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = {{prefix}}.query_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_double_eq, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_eq, RIGHTARG = eql_v3.query_double_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_eq, RIGHTARG = {{prefix}}.query_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.eql_v3_double_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_double_eq, RIGHTARG = public.{{prefix}}_double_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql index ba4719765..de3f645c5 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/double/double_ord_functions.sql --! @file encrypted_domain/double/query_double_ord_functions.sql ---! @brief Functions for eql_v3.query_double_ord. +--! @brief Functions for {{prefix}}.query_double_ord. ---! @brief Index extractor for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_double_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a public.eql_v3_double_ord ---! @param b eql_v3.query_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a public.{{prefix}}_double_ord +--! @param b {{prefix}}.query_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord, b eql_v3.query_double_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord, b {{prefix}}.query_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord. ---! @param a eql_v3.query_double_ord ---! @param b public.eql_v3_double_ord +--! @brief Operator wrapper for {{prefix}}.query_double_ord. +--! @param a {{prefix}}.query_double_ord +--! @param b public.{{prefix}}_double_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_double_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord, b public.{{prefix}}_double_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql index a9d2f760e..dfa4f5908 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ope_functions.sql --! @file encrypted_domain/double/query_double_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ope. +--! @brief Functions for {{prefix}}.query_double_ord_ope. ---! @brief Index extractor for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_double_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a public.eql_v3_double_ord_ope ---! @param b eql_v3.query_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a public.{{prefix}}_double_ord_ope +--! @param b {{prefix}}.query_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ope, b eql_v3.query_double_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ope, b {{prefix}}.query_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ope. ---! @param a eql_v3.query_double_ord_ope ---! @param b public.eql_v3_double_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ope. +--! @param a {{prefix}}.query_double_ord_ope +--! @param b public.{{prefix}}_double_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_double_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ope, b public.{{prefix}}_double_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql index 6976b9e3b..99f6594d2 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/double/query_double_ord_ope_functions.sql --! @file encrypted_domain/double/query_double_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ope. +--! @brief Operators for {{prefix}}.query_double_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ope, RIGHTARG = {{prefix}}.query_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_double_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_double_ord_ope, RIGHTARG = public.{{prefix}}_double_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql index 4f7571aa3..fe4aa9e5e 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/double/query_double_ord_functions.sql --! @file encrypted_domain/double/query_double_ord_operators.sql ---! @brief Operators for eql_v3.query_double_ord. +--! @brief Operators for {{prefix}}.query_double_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord, RIGHTARG = eql_v3.query_double_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord, RIGHTARG = {{prefix}}.query_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_double_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_double_ord, RIGHTARG = public.{{prefix}}_double_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql index b916c2c40..e7e95f291 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/double/double_ord_ore_functions.sql --! @file encrypted_domain/double/query_double_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_double_ord_ore. +--! @brief Functions for {{prefix}}.query_double_ord_ore. ---! @brief Index extractor for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_double_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_double_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a public.eql_v3_double_ord_ore ---! @param b eql_v3.query_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a public.{{prefix}}_double_ord_ore +--! @param b {{prefix}}.query_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_double_ord_ore, b eql_v3.query_double_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_double_ord_ore, b {{prefix}}.query_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_double_ord_ore. ---! @param a eql_v3.query_double_ord_ore ---! @param b public.eql_v3_double_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_double_ord_ore. +--! @param a {{prefix}}.query_double_ord_ore +--! @param b public.{{prefix}}_double_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.eql_v3_double_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_double_ord_ore, b public.{{prefix}}_double_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql b/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql index 56ec45934..00a024cc5 100644 --- a/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/double/query_double_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/double/query_double_ord_ore_functions.sql --! @file encrypted_domain/double/query_double_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_double_ord_ore. +--! @brief Operators for {{prefix}}.query_double_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_double_ord_ore, RIGHTARG = {{prefix}}.query_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.eql_v3_double_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_double_ord_ore, RIGHTARG = public.{{prefix}}_double_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/double/query_double_types.sql b/packages/eql/src/v3/scalars/double/query_double_types.sql index 87362cdfc..9ab265bf5 100644 --- a/packages/eql/src/v3/scalars/double/query_double_types.sql +++ b/packages/eql/src/v3/scalars/double/query_double_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/double/query_double_types.sql --! @brief Query-operand domains for double (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_double_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_double_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_double_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_double_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_double_eq IS 'EQL double query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_double_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_double_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_double_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_double_ord_ore IS 'EQL double query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_double_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_double_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_double_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_double_ord IS 'EQL double query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_double_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_double_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_double_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_double_ord_ope IS 'EQL double query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql b/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql index 80e3e01d6..8247eb048 100644 --- a/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql +++ b/packages/eql/src/v3/scalars/integer/integer_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/integer/integer_eq_functions.sql ---! @brief Functions for public.eql_v3_integer_eq. +--! @brief Functions for public.{{prefix}}_integer_eq. ---! @brief Index extractor for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_integer_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_integer_eq. +--! @param a public.{{prefix}}_integer_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_integer_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. +--! @param a public.{{prefix}}_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. +--! @param a public.{{prefix}}_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_integer_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. +--! @param a public.{{prefix}}_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. ---! @param a public.eql_v3_integer_eq +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. +--! @param a public.{{prefix}}_integer_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_integer_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_integer_eq) $$; ---! @brief Operator wrapper for public.eql_v3_integer_eq. +--! @brief Operator wrapper for public.{{prefix}}_integer_eq. --! @param a jsonb ---! @param b public.eql_v3_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_integer_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_integer_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector text) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ +--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_eq, selector text) +RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_eq, selector integer) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ +--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_eq, selector integer) +RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_eq right operand of the blocked operator ---! @return public.eql_v3_integer_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_eq) -RETURNS public.eql_v3_integer_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_eq'; END; $$ +--! @param selector public.{{prefix}}_integer_eq right operand of the blocked operator +--! @return public.{{prefix}}_integer_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_eq) +RETURNS public.{{prefix}}_integer_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_integer_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_eq, b public.{{prefix}}_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_eq left operand of the blocked operator +--! @param a public.{{prefix}}_integer_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_eq right operand of the blocked operator +--! @param b public.{{prefix}}_integer_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql b/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql index 2848d6fe1..39a296bf6 100644 --- a/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql +++ b/packages/eql/src/v3/scalars/integer/integer_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/integer/integer_eq_functions.sql --! @file encrypted_domain/integer/integer_eq_operators.sql ---! @brief Operators for public.eql_v3_integer_eq. +--! @brief Operators for public.{{prefix}}_integer_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_eq ); diff --git a/packages/eql/src/v3/scalars/integer/integer_functions.sql b/packages/eql/src/v3/scalars/integer/integer_functions.sql index c6fe4631d..560626ecb 100644 --- a/packages/eql/src/v3/scalars/integer/integer_functions.sql +++ b/packages/eql/src/v3/scalars/integer/integer_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/integer/integer_functions.sql ---! @brief Functions for public.eql_v3_integer. +--! @brief Functions for public.{{prefix}}_integer. ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_integer never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector text) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer, selector text) +RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_integer never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer, selector integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer, selector integer) +RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer right operand of the blocked operator ---! @return public.eql_v3_integer never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer) -RETURNS public.eql_v3_integer IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer'; END; $$ +--! @param selector public.{{prefix}}_integer right operand of the blocked operator +--! @return public.{{prefix}}_integer never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer) +RETURNS public.{{prefix}}_integer IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer right operand of the blocked operator +--! @param selector public.{{prefix}}_integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer, b public.{{prefix}}_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer left operand of the blocked operator +--! @param a public.{{prefix}}_integer left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer right operand of the blocked operator +--! @param b public.{{prefix}}_integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/integer/integer_operators.sql b/packages/eql/src/v3/scalars/integer/integer_operators.sql index 476bbd5cf..14c37d131 100644 --- a/packages/eql/src/v3/scalars/integer/integer_operators.sql +++ b/packages/eql/src/v3/scalars/integer/integer_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/integer/integer_functions.sql --! @file encrypted_domain/integer/integer_operators.sql ---! @brief Operators for public.eql_v3_integer. +--! @brief Operators for public.{{prefix}}_integer. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = public.{{prefix}}_integer ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql index 2f7ead251..7be4947f8 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_operators.sql --! @file encrypted_domain/integer/integer_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord. +--! @brief Aggregates for public.{{prefix}}_integer_ord. ---! @brief State function for min on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord +--! @brief State function for min on public.{{prefix}}_integer_ord. +--! @param state public.{{prefix}}_integer_ord +--! @param value public.{{prefix}}_integer_ord +--! @return public.{{prefix}}_integer_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord, value public.{{prefix}}_integer_ord) +RETURNS public.{{prefix}}_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_integer_ord. +--! @param input public.{{prefix}}_integer_ord +--! @return public.{{prefix}}_integer_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_integer_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_integer_ord. ---! @param state public.eql_v3_integer_ord ---! @param value public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord, value public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord +--! @brief State function for max on public.{{prefix}}_integer_ord. +--! @param state public.{{prefix}}_integer_ord +--! @param value public.{{prefix}}_integer_ord +--! @return public.{{prefix}}_integer_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord, value public.{{prefix}}_integer_ord) +RETURNS public.{{prefix}}_integer_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_integer_ord. ---! @param input public.eql_v3_integer_ord ---! @return public.eql_v3_integer_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_integer_ord. +--! @param input public.{{prefix}}_integer_ord +--! @return public.{{prefix}}_integer_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_integer_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql index ae6de7ef8..b1ba2ddae 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/integer/integer_ord_functions.sql ---! @brief Functions for public.eql_v3_integer_ord. +--! @brief Functions for public.{{prefix}}_integer_ord. ---! @brief Index extractor for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_integer_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. ---! @param a public.eql_v3_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. +--! @param a public.{{prefix}}_integer_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord. --! @param a jsonb ---! @param b public.eql_v3_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector text) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord, selector text) +RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord, selector integer) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord, selector integer) +RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord right operand of the blocked operator ---! @return public.eql_v3_integer_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord) -RETURNS public.eql_v3_integer_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord'; END; $$ +--! @param selector public.{{prefix}}_integer_ord right operand of the blocked operator +--! @return public.{{prefix}}_integer_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord) +RETURNS public.{{prefix}}_integer_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_integer_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord, b public.{{prefix}}_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql index 7249ef061..059178bbd 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_operators.sql --! @file encrypted_domain/integer/integer_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ope. +--! @brief Aggregates for public.{{prefix}}_integer_ord_ope. ---! @brief State function for min on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope +--! @brief State function for min on public.{{prefix}}_integer_ord_ope. +--! @param state public.{{prefix}}_integer_ord_ope +--! @param value public.{{prefix}}_integer_ord_ope +--! @return public.{{prefix}}_integer_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord_ope, value public.{{prefix}}_integer_ord_ope) +RETURNS public.{{prefix}}_integer_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_integer_ord_ope. +--! @param input public.{{prefix}}_integer_ord_ope +--! @return public.{{prefix}}_integer_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_integer_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_integer_ord_ope. ---! @param state public.eql_v3_integer_ord_ope ---! @param value public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ope, value public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope +--! @brief State function for max on public.{{prefix}}_integer_ord_ope. +--! @param state public.{{prefix}}_integer_ord_ope +--! @param value public.{{prefix}}_integer_ord_ope +--! @return public.{{prefix}}_integer_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord_ope, value public.{{prefix}}_integer_ord_ope) +RETURNS public.{{prefix}}_integer_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ope. ---! @param input public.eql_v3_integer_ord_ope ---! @return public.eql_v3_integer_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_integer_ord_ope. +--! @param input public.{{prefix}}_integer_ord_ope +--! @return public.{{prefix}}_integer_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_integer_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql index 68d4b9e2a..dc9b5a81b 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/integer/integer_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ope. +--! @brief Functions for public.{{prefix}}_integer_ord_ope. ---! @brief Index extractor for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_integer_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_integer_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_integer_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_integer_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_integer_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector text) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ope, selector text) +RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ope, selector integer) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ope, selector integer) +RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ope) -RETURNS public.eql_v3_integer_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_integer_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_integer_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord_ope) +RETURNS public.{{prefix}}_integer_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql index 8f8c319a8..7ff34c060 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_functions.sql --! @file encrypted_domain/integer/integer_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ope. +--! @brief Operators for public.{{prefix}}_integer_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ope ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql index f5d9dcaa5..241961bb2 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_functions.sql --! @file encrypted_domain/integer/integer_ord_operators.sql ---! @brief Operators for public.eql_v3_integer_ord. +--! @brief Operators for public.{{prefix}}_integer_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql index d920423b0..e3a488d93 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_operators.sql --! @file encrypted_domain/integer/integer_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_integer_ord_ore. +--! @brief Aggregates for public.{{prefix}}_integer_ord_ore. ---! @brief State function for min on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore +--! @brief State function for min on public.{{prefix}}_integer_ord_ore. +--! @param state public.{{prefix}}_integer_ord_ore +--! @param value public.{{prefix}}_integer_ord_ore +--! @return public.{{prefix}}_integer_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_integer_ord_ore, value public.{{prefix}}_integer_ord_ore) +RETURNS public.{{prefix}}_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_integer_ord_ore. +--! @param input public.{{prefix}}_integer_ord_ore +--! @return public.{{prefix}}_integer_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_integer_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_integer_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_integer_ord_ore. ---! @param state public.eql_v3_integer_ord_ore ---! @param value public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_integer_ord_ore, value public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore +--! @brief State function for max on public.{{prefix}}_integer_ord_ore. +--! @param state public.{{prefix}}_integer_ord_ore +--! @param value public.{{prefix}}_integer_ord_ore +--! @return public.{{prefix}}_integer_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_integer_ord_ore, value public.{{prefix}}_integer_ord_ore) +RETURNS public.{{prefix}}_integer_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_integer_ord_ore. ---! @param input public.eql_v3_integer_ord_ore ---! @return public.eql_v3_integer_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_integer_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_integer_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_integer_ord_ore. +--! @param input public.{{prefix}}_integer_ord_ore +--! @return public.{{prefix}}_integer_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_integer_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_integer_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql index e4518aa9b..4bfd5d2eb 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/integer/integer_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_integer_ord_ore. +--! @brief Functions for public.{{prefix}}_integer_ord_ore. ---! @brief Index extractor for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_integer_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_integer_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_integer_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_integer_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_integer_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_integer_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_integer_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector text) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ore, selector text) +RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_integer_ord_ore, selector integer) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_integer_ord_ore, selector integer) +RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator ---! @return public.eql_v3_integer_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_integer_ord_ore) -RETURNS public.eql_v3_integer_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_integer_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_integer_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_integer_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_integer_ord_ore) +RETURNS public.{{prefix}}_integer_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_integer_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_integer_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_integer_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_integer_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_integer_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_integer_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_integer_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_integer_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_integer_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_integer_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_integer_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_integer_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_integer_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_integer_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_integer_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_integer_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_integer_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_integer_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql b/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql index ed50f6297..16126e76c 100644 --- a/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/integer/integer_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_functions.sql --! @file encrypted_domain/integer/integer_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_integer_ord_ore. +--! @brief Operators for public.{{prefix}}_integer_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_integer_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_integer_ord_ore ); diff --git a/packages/eql/src/v3/scalars/integer/integer_types.sql b/packages/eql/src/v3/scalars/integer/integer_types.sql index 94e791d99..b10c0ad7f 100644 --- a/packages/eql/src/v3/scalars/integer/integer_types.sql +++ b/packages/eql/src/v3/scalars/integer/integer_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_integer. + --! @brief Encrypted domain public.{{prefix}}_integer. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_integer' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_integer' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_integer AS jsonb + CREATE DOMAIN public.{{prefix}}_integer AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_integer IS 'EQL encrypted integer (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_integer IS 'EQL encrypted integer (storage only)'; - --! @brief Encrypted domain public.eql_v3_integer_eq. + --! @brief Encrypted domain public.{{prefix}}_integer_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_integer_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_integer_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_integer_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_integer_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_integer_eq IS 'EQL encrypted integer (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_integer_eq IS 'EQL encrypted integer (equality)'; - --! @brief Encrypted domain public.eql_v3_integer_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_integer_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_integer_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_integer_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_integer_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_integer_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_integer_ord_ore IS 'EQL encrypted integer (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_integer_ord. + --! @brief Encrypted domain public.{{prefix}}_integer_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_integer_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_integer_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_integer_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_integer_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_integer_ord IS 'EQL encrypted integer (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_integer_ord IS 'EQL encrypted integer (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_integer_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_integer_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_integer_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_integer_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_integer_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_integer_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_integer_ord_ope IS 'EQL encrypted integer (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql b/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql index f48c4e855..b46db4e60 100644 --- a/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql +++ b/packages/eql/src/v3/scalars/integer/json_entry_integer_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ope_functions.sql --! @file encrypted_domain/integer/json_entry_integer_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_integer_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_integer_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_integer_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_integer_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_integer_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_integer_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql b/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql index a8b63c55b..f58a9ca2c 100644 --- a/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql +++ b/packages/eql/src/v3/scalars/integer/json_entry_integer_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/integer/json_entry_integer_functions.sql --! @file encrypted_domain/integer/json_entry_integer_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql index de478f5a7..003be0b36 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/integer/integer_eq_functions.sql --! @file encrypted_domain/integer/query_integer_eq_functions.sql ---! @brief Functions for eql_v3.query_integer_eq. +--! @brief Functions for {{prefix}}.query_integer_eq. ---! @brief Index extractor for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_integer_eq. +--! @param a {{prefix}}.query_integer_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_integer_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq +--! @brief Operator wrapper for {{prefix}}.query_integer_eq. +--! @param a public.{{prefix}}_integer_eq +--! @param b {{prefix}}.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_eq, b {{prefix}}.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for {{prefix}}.query_integer_eq. +--! @param a {{prefix}}.query_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a public.eql_v3_integer_eq ---! @param b eql_v3.query_integer_eq +--! @brief Operator wrapper for {{prefix}}.query_integer_eq. +--! @param a public.{{prefix}}_integer_eq +--! @param b {{prefix}}.query_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_eq, b eql_v3.query_integer_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_eq, b {{prefix}}.query_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_eq. ---! @param a eql_v3.query_integer_eq ---! @param b public.eql_v3_integer_eq +--! @brief Operator wrapper for {{prefix}}.query_integer_eq. +--! @param a {{prefix}}.query_integer_eq +--! @param b public.{{prefix}}_integer_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.eql_v3_integer_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_eq, b public.{{prefix}}_integer_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql index 527d5f7eb..70693b1e7 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/integer/query_integer_eq_functions.sql --! @file encrypted_domain/integer/query_integer_eq_operators.sql ---! @brief Operators for eql_v3.query_integer_eq. +--! @brief Operators for {{prefix}}.query_integer_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = {{prefix}}.query_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_eq, RIGHTARG = eql_v3.query_integer_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_eq, RIGHTARG = {{prefix}}.query_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.eql_v3_integer_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_integer_eq, RIGHTARG = public.{{prefix}}_integer_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql index c730a223a..ad0592020 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_functions.sql --! @file encrypted_domain/integer/query_integer_ord_functions.sql ---! @brief Functions for eql_v3.query_integer_ord. +--! @brief Functions for {{prefix}}.query_integer_ord. ---! @brief Index extractor for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_integer_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a public.eql_v3_integer_ord ---! @param b eql_v3.query_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a public.{{prefix}}_integer_ord +--! @param b {{prefix}}.query_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord, b eql_v3.query_integer_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord, b {{prefix}}.query_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord. ---! @param a eql_v3.query_integer_ord ---! @param b public.eql_v3_integer_ord +--! @brief Operator wrapper for {{prefix}}.query_integer_ord. +--! @param a {{prefix}}.query_integer_ord +--! @param b public.{{prefix}}_integer_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_integer_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord, b public.{{prefix}}_integer_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql index 3ee5f5ad9..6f643a649 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_functions.sql --! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ope. +--! @brief Functions for {{prefix}}.query_integer_ord_ope. ---! @brief Index extractor for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_integer_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a public.eql_v3_integer_ord_ope ---! @param b eql_v3.query_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a public.{{prefix}}_integer_ord_ope +--! @param b {{prefix}}.query_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ope, b eql_v3.query_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ope, b {{prefix}}.query_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ope. ---! @param a eql_v3.query_integer_ord_ope ---! @param b public.eql_v3_integer_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ope. +--! @param a {{prefix}}.query_integer_ord_ope +--! @param b public.{{prefix}}_integer_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_integer_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ope, b public.{{prefix}}_integer_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql index 7936100c4..fb5505e1b 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ope_functions.sql --! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ope. +--! @brief Operators for {{prefix}}.query_integer_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ope, RIGHTARG = {{prefix}}.query_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_integer_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_integer_ord_ope, RIGHTARG = public.{{prefix}}_integer_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql index df7da7cb5..786245e45 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/integer/query_integer_ord_functions.sql --! @file encrypted_domain/integer/query_integer_ord_operators.sql ---! @brief Operators for eql_v3.query_integer_ord. +--! @brief Operators for {{prefix}}.query_integer_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord, RIGHTARG = eql_v3.query_integer_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord, RIGHTARG = {{prefix}}.query_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_integer_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_integer_ord, RIGHTARG = public.{{prefix}}_integer_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql index c66973750..3578cfb1a 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_functions.sql --! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_integer_ord_ore. +--! @brief Functions for {{prefix}}.query_integer_ord_ore. ---! @brief Index extractor for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_integer_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_integer_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a public.eql_v3_integer_ord_ore ---! @param b eql_v3.query_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a public.{{prefix}}_integer_ord_ore +--! @param b {{prefix}}.query_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_integer_ord_ore, b eql_v3.query_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_integer_ord_ore, b {{prefix}}.query_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_integer_ord_ore. ---! @param a eql_v3.query_integer_ord_ore ---! @param b public.eql_v3_integer_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_integer_ord_ore. +--! @param a {{prefix}}.query_integer_ord_ore +--! @param b public.{{prefix}}_integer_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.eql_v3_integer_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_integer_ord_ore, b public.{{prefix}}_integer_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql index c1a6b6025..d897eac84 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/integer/query_integer_ord_ore_functions.sql --! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_integer_ord_ore. +--! @brief Operators for {{prefix}}.query_integer_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_integer_ord_ore, RIGHTARG = {{prefix}}.query_integer_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.eql_v3_integer_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_integer_ord_ore, RIGHTARG = public.{{prefix}}_integer_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/integer/query_integer_types.sql b/packages/eql/src/v3/scalars/integer/query_integer_types.sql index 697581072..62eb3a3f1 100644 --- a/packages/eql/src/v3/scalars/integer/query_integer_types.sql +++ b/packages/eql/src/v3/scalars/integer/query_integer_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/integer/query_integer_types.sql --! @brief Query-operand domains for integer (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_integer_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_integer_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_integer_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_integer_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_integer_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_integer_eq IS 'EQL integer query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_integer_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_integer_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_integer_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_integer_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_integer_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_integer_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_integer_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_integer_ord IS 'EQL integer query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_integer_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_integer_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_integer_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/json/json_functions.sql b/packages/eql/src/v3/scalars/json/json_functions.sql index ad5ca52a7..ee6cf992f 100644 --- a/packages/eql/src/v3/scalars/json/json_functions.sql +++ b/packages/eql/src/v3/scalars/json/json_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/json/json_functions.sql ---! @brief Functions for public.eql_v3_json. +--! @brief Functions for public.{{prefix}}_json. ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_json never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector text) -RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_json, selector text) +RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_json never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_json, selector integer) -RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_json, selector integer) +RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_json right operand of the blocked operator ---! @return public.eql_v3_json never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_json) -RETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$ +--! @param selector public.{{prefix}}_json right operand of the blocked operator +--! @return public.{{prefix}}_json never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_json) +RETURNS public.{{prefix}}_json IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_json, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_json, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_json, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_json right operand of the blocked operator +--! @param selector public.{{prefix}}_json right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_json) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_json, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_json, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_json, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_json) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_json, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_json, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_json, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_json, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_json, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_json, b public.{{prefix}}_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json left operand of the blocked operator +--! @param a public.{{prefix}}_json left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_json, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_json, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json. +--! @brief Unsupported operator blocker for public.{{prefix}}_json. --! ---! Intercepts an operator that is not supported on public.eql_v3_json and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_json right operand of the blocked operator +--! @param b public.{{prefix}}_json right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_json) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_json) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_json'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/json/json_operators.sql b/packages/eql/src/v3/scalars/json/json_operators.sql index 21cdfd15b..e3937f294 100644 --- a/packages/eql/src/v3/scalars/json/json_operators.sql +++ b/packages/eql/src/v3/scalars/json/json_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/json/json_functions.sql --! @file encrypted_domain/json/json_operators.sql ---! @brief Operators for public.eql_v3_json. +--! @brief Operators for public.{{prefix}}_json. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_json, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_json, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_json, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_json, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_json, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_json, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_json, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_json, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_json, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_json, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_json, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_json, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_json, RIGHTARG = public.{{prefix}}_json ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_json, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_json, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_json + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_json ); diff --git a/packages/eql/src/v3/scalars/json/json_types.sql b/packages/eql/src/v3/scalars/json/json_types.sql index bebe5d0b6..047dc2091 100644 --- a/packages/eql/src/v3/scalars/json/json_types.sql +++ b/packages/eql/src/v3/scalars/json/json_types.sql @@ -6,21 +6,21 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_json. + --! @brief Encrypted domain public.{{prefix}}_json. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_json' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_json' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_json AS jsonb + CREATE DOMAIN public.{{prefix}}_json AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_json IS 'EQL encrypted json (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_json IS 'EQL encrypted json (storage only)'; END $$; diff --git a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql index fd20146ea..4d32069a1 100644 --- a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql --! @file encrypted_domain/numeric/json_entry_numeric_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql index 2f204e242..49aad090b 100644 --- a/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/json_entry_numeric_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/numeric/json_entry_numeric_functions.sql --! @file encrypted_domain/numeric/json_entry_numeric_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql index fe3ebd54f..a69b33759 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/numeric/numeric_eq_functions.sql ---! @brief Functions for public.eql_v3_numeric_eq. +--! @brief Functions for public.{{prefix}}_numeric_eq. ---! @brief Index extractor for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_numeric_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_numeric_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_numeric_eq) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. --! @param a jsonb ---! @param b public.eql_v3_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_numeric_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b public.eql_v3_numeric_eq +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. ---! @param a public.eql_v3_numeric_eq +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_numeric_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_numeric_eq) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_eq. +--! @brief Operator wrapper for public.{{prefix}}_numeric_eq. --! @param a jsonb ---! @param b public.eql_v3_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_numeric_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_numeric_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector text) -RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ +--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_eq, selector text) +RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_eq, selector integer) -RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ +--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_eq, selector integer) +RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_eq right operand of the blocked operator ---! @return public.eql_v3_numeric_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_eq) -RETURNS public.eql_v3_numeric_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_eq'; END; $$ +--! @param selector public.{{prefix}}_numeric_eq right operand of the blocked operator +--! @return public.{{prefix}}_numeric_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_eq) +RETURNS public.{{prefix}}_numeric_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_eq left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_eq right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql index 1b9a16b7c..b606cae88 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_eq_functions.sql --! @file encrypted_domain/numeric/numeric_eq_operators.sql ---! @brief Operators for public.eql_v3_numeric_eq. +--! @brief Operators for public.{{prefix}}_numeric_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_eq ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_functions.sql index 82001f519..7b591444a 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/numeric/numeric_functions.sql ---! @brief Functions for public.eql_v3_numeric. +--! @brief Functions for public.{{prefix}}_numeric. ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector text) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric, selector text) +RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric, selector integer) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric, selector integer) +RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric right operand of the blocked operator ---! @return public.eql_v3_numeric never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric) -RETURNS public.eql_v3_numeric IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric'; END; $$ +--! @param selector public.{{prefix}}_numeric right operand of the blocked operator +--! @return public.{{prefix}}_numeric never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric) +RETURNS public.{{prefix}}_numeric IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric right operand of the blocked operator +--! @param selector public.{{prefix}}_numeric right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric, b public.{{prefix}}_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric left operand of the blocked operator +--! @param a public.{{prefix}}_numeric left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric right operand of the blocked operator +--! @param b public.{{prefix}}_numeric right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/numeric/numeric_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_operators.sql index 9beeedd2b..fe88b6086 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_functions.sql --! @file encrypted_domain/numeric/numeric_operators.sql ---! @brief Operators for public.eql_v3_numeric. +--! @brief Operators for public.{{prefix}}_numeric. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = public.{{prefix}}_numeric ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql index 428a5cc00..2d76d14ed 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_operators.sql --! @file encrypted_domain/numeric/numeric_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord. +--! @brief Aggregates for public.{{prefix}}_numeric_ord. ---! @brief State function for min on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord +--! @brief State function for min on public.{{prefix}}_numeric_ord. +--! @param state public.{{prefix}}_numeric_ord +--! @param value public.{{prefix}}_numeric_ord +--! @return public.{{prefix}}_numeric_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord, value public.{{prefix}}_numeric_ord) +RETURNS public.{{prefix}}_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_numeric_ord. +--! @param input public.{{prefix}}_numeric_ord +--! @return public.{{prefix}}_numeric_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_numeric_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_numeric_ord. ---! @param state public.eql_v3_numeric_ord ---! @param value public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord, value public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord +--! @brief State function for max on public.{{prefix}}_numeric_ord. +--! @param state public.{{prefix}}_numeric_ord +--! @param value public.{{prefix}}_numeric_ord +--! @return public.{{prefix}}_numeric_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord, value public.{{prefix}}_numeric_ord) +RETURNS public.{{prefix}}_numeric_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_numeric_ord. ---! @param input public.eql_v3_numeric_ord ---! @return public.eql_v3_numeric_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_numeric_ord. +--! @param input public.{{prefix}}_numeric_ord +--! @return public.{{prefix}}_numeric_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_numeric_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql index bd7d97471..079c1be40 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/numeric/numeric_ord_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord. +--! @brief Functions for public.{{prefix}}_numeric_ord. ---! @brief Index extractor for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_numeric_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. ---! @param a public.eql_v3_numeric_ord +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector text) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ +--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord, selector text) +RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord, selector integer) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ +--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord, selector integer) +RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord right operand of the blocked operator ---! @return public.eql_v3_numeric_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord) -RETURNS public.eql_v3_numeric_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord'; END; $$ +--! @param selector public.{{prefix}}_numeric_ord right operand of the blocked operator +--! @return public.{{prefix}}_numeric_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord) +RETURNS public.{{prefix}}_numeric_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql index 4190c25d9..f0627aafc 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_operators.sql --! @file encrypted_domain/numeric/numeric_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ope. +--! @brief Aggregates for public.{{prefix}}_numeric_ord_ope. ---! @brief State function for min on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope +--! @brief State function for min on public.{{prefix}}_numeric_ord_ope. +--! @param state public.{{prefix}}_numeric_ord_ope +--! @param value public.{{prefix}}_numeric_ord_ope +--! @return public.{{prefix}}_numeric_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord_ope, value public.{{prefix}}_numeric_ord_ope) +RETURNS public.{{prefix}}_numeric_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_numeric_ord_ope. +--! @param input public.{{prefix}}_numeric_ord_ope +--! @return public.{{prefix}}_numeric_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_numeric_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_numeric_ord_ope. ---! @param state public.eql_v3_numeric_ord_ope ---! @param value public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ope, value public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope +--! @brief State function for max on public.{{prefix}}_numeric_ord_ope. +--! @param state public.{{prefix}}_numeric_ord_ope +--! @param value public.{{prefix}}_numeric_ord_ope +--! @return public.{{prefix}}_numeric_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord_ope, value public.{{prefix}}_numeric_ord_ope) +RETURNS public.{{prefix}}_numeric_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_numeric_ord_ope. ---! @param input public.eql_v3_numeric_ord_ope ---! @return public.eql_v3_numeric_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_numeric_ord_ope. +--! @param input public.{{prefix}}_numeric_ord_ope +--! @return public.{{prefix}}_numeric_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_numeric_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql index 5f2f4ec32..4ca0974f4 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/numeric/numeric_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ope. +--! @brief Functions for public.{{prefix}}_numeric_ord_ope. ---! @brief Index extractor for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_numeric_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_numeric_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_numeric_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_numeric_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_numeric_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector text) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ +--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ope, selector text) +RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ope, selector integer) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ +--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ope, selector integer) +RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ope) -RETURNS public.eql_v3_numeric_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_numeric_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_numeric_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord_ope) +RETURNS public.{{prefix}}_numeric_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql index 26f446e46..ab374cb5f 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_functions.sql --! @file encrypted_domain/numeric/numeric_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ope. +--! @brief Operators for public.{{prefix}}_numeric_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ope ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql index c3f29d217..7fb87b0c1 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_functions.sql --! @file encrypted_domain/numeric/numeric_ord_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord. +--! @brief Operators for public.{{prefix}}_numeric_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql index 83f2c2f2a..76db0474c 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_operators.sql --! @file encrypted_domain/numeric/numeric_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_numeric_ord_ore. +--! @brief Aggregates for public.{{prefix}}_numeric_ord_ore. ---! @brief State function for min on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore +--! @brief State function for min on public.{{prefix}}_numeric_ord_ore. +--! @param state public.{{prefix}}_numeric_ord_ore +--! @param value public.{{prefix}}_numeric_ord_ore +--! @return public.{{prefix}}_numeric_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_numeric_ord_ore, value public.{{prefix}}_numeric_ord_ore) +RETURNS public.{{prefix}}_numeric_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_numeric_ord_ore. +--! @param input public.{{prefix}}_numeric_ord_ore +--! @return public.{{prefix}}_numeric_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_numeric_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_numeric_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_numeric_ord_ore. ---! @param state public.eql_v3_numeric_ord_ore ---! @param value public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_numeric_ord_ore, value public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore +--! @brief State function for max on public.{{prefix}}_numeric_ord_ore. +--! @param state public.{{prefix}}_numeric_ord_ore +--! @param value public.{{prefix}}_numeric_ord_ore +--! @return public.{{prefix}}_numeric_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_numeric_ord_ore, value public.{{prefix}}_numeric_ord_ore) +RETURNS public.{{prefix}}_numeric_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_numeric_ord_ore. ---! @param input public.eql_v3_numeric_ord_ore ---! @return public.eql_v3_numeric_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_numeric_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_numeric_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_numeric_ord_ore. +--! @param input public.{{prefix}}_numeric_ord_ore +--! @return public.{{prefix}}_numeric_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_numeric_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_numeric_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql index 5481863bc..748793ea5 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/numeric/numeric_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_numeric_ord_ore. +--! @brief Functions for public.{{prefix}}_numeric_ord_ore. ---! @brief Index extractor for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_numeric_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_numeric_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_numeric_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_numeric_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_numeric_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_numeric_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_numeric_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector text) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ore, selector text) +RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_numeric_ord_ore, selector integer) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_numeric_ord_ore, selector integer) +RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator ---! @return public.eql_v3_numeric_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_numeric_ord_ore) -RETURNS public.eql_v3_numeric_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_numeric_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_numeric_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_numeric_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_numeric_ord_ore) +RETURNS public.{{prefix}}_numeric_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_numeric_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_numeric_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_numeric_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_numeric_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_numeric_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_numeric_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_numeric_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_numeric_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_numeric_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_numeric_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_numeric_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_numeric_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_numeric_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_numeric_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_numeric_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_numeric_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_numeric_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_numeric_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql index ed2e72be8..c017dd604 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_functions.sql --! @file encrypted_domain/numeric/numeric_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_numeric_ord_ore. +--! @brief Operators for public.{{prefix}}_numeric_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_numeric_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_numeric_ord_ore ); diff --git a/packages/eql/src/v3/scalars/numeric/numeric_types.sql b/packages/eql/src/v3/scalars/numeric/numeric_types.sql index 3ee6c9627..37852ac11 100644 --- a/packages/eql/src/v3/scalars/numeric/numeric_types.sql +++ b/packages/eql/src/v3/scalars/numeric/numeric_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_numeric. + --! @brief Encrypted domain public.{{prefix}}_numeric. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_numeric' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric AS jsonb + CREATE DOMAIN public.{{prefix}}_numeric AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric IS 'EQL encrypted numeric (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_numeric IS 'EQL encrypted numeric (storage only)'; - --! @brief Encrypted domain public.eql_v3_numeric_eq. + --! @brief Encrypted domain public.{{prefix}}_numeric_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_numeric_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_eq IS 'EQL encrypted numeric (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_numeric_eq IS 'EQL encrypted numeric (equality)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_numeric_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_numeric_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_numeric_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_numeric_ord_ore IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord. + --! @brief Encrypted domain public.{{prefix}}_numeric_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_numeric_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_numeric_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_numeric_ord IS 'EQL encrypted numeric (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_numeric_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_numeric_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_numeric_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_numeric_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_numeric_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_numeric_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_numeric_ord_ope IS 'EQL encrypted numeric (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql index 7286732dc..b250bac08 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_eq_functions.sql --! @file encrypted_domain/numeric/query_numeric_eq_functions.sql ---! @brief Functions for eql_v3.query_numeric_eq. +--! @brief Functions for {{prefix}}.query_numeric_eq. ---! @brief Index extractor for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_numeric_eq. +--! @param a {{prefix}}.query_numeric_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_numeric_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq +--! @brief Operator wrapper for {{prefix}}.query_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq +--! @param b {{prefix}}.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_eq, b {{prefix}}.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq +--! @brief Operator wrapper for {{prefix}}.query_numeric_eq. +--! @param a {{prefix}}.query_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a public.eql_v3_numeric_eq ---! @param b eql_v3.query_numeric_eq +--! @brief Operator wrapper for {{prefix}}.query_numeric_eq. +--! @param a public.{{prefix}}_numeric_eq +--! @param b {{prefix}}.query_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_eq, b eql_v3.query_numeric_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_eq, b {{prefix}}.query_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_eq. ---! @param a eql_v3.query_numeric_eq ---! @param b public.eql_v3_numeric_eq +--! @brief Operator wrapper for {{prefix}}.query_numeric_eq. +--! @param a {{prefix}}.query_numeric_eq +--! @param b public.{{prefix}}_numeric_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.eql_v3_numeric_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_eq, b public.{{prefix}}_numeric_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql index 046b26a63..78ad85f81 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/numeric/query_numeric_eq_functions.sql --! @file encrypted_domain/numeric/query_numeric_eq_operators.sql ---! @brief Operators for eql_v3.query_numeric_eq. +--! @brief Operators for {{prefix}}.query_numeric_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = {{prefix}}.query_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_eq, RIGHTARG = eql_v3.query_numeric_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_eq, RIGHTARG = {{prefix}}.query_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.eql_v3_numeric_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_numeric_eq, RIGHTARG = public.{{prefix}}_numeric_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql index 104bd7125..08cfcf2fc 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord. +--! @brief Functions for {{prefix}}.query_numeric_ord. ---! @brief Index extractor for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_numeric_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a public.eql_v3_numeric_ord ---! @param b eql_v3.query_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a public.{{prefix}}_numeric_ord +--! @param b {{prefix}}.query_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord, b eql_v3.query_numeric_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord, b {{prefix}}.query_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord. ---! @param a eql_v3.query_numeric_ord ---! @param b public.eql_v3_numeric_ord +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord. +--! @param a {{prefix}}.query_numeric_ord +--! @param b public.{{prefix}}_numeric_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_numeric_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord, b public.{{prefix}}_numeric_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql index 41f326c5a..cafc3daa9 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ope. +--! @brief Functions for {{prefix}}.query_numeric_ord_ope. ---! @brief Index extractor for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_numeric_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a public.eql_v3_numeric_ord_ope ---! @param b eql_v3.query_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a public.{{prefix}}_numeric_ord_ope +--! @param b {{prefix}}.query_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ope, b eql_v3.query_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ope, b {{prefix}}.query_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ope. ---! @param a eql_v3.query_numeric_ord_ope ---! @param b public.eql_v3_numeric_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ope. +--! @param a {{prefix}}.query_numeric_ord_ope +--! @param b public.{{prefix}}_numeric_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_numeric_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ope, b public.{{prefix}}_numeric_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql index fa3d91bd1..2a16ae3af 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ope. +--! @brief Operators for {{prefix}}.query_numeric_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ope, RIGHTARG = {{prefix}}.query_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_numeric_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_numeric_ord_ope, RIGHTARG = public.{{prefix}}_numeric_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql index e88a4aa28..88ba9557e 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord. +--! @brief Operators for {{prefix}}.query_numeric_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord, RIGHTARG = eql_v3.query_numeric_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord, RIGHTARG = {{prefix}}.query_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_numeric_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_numeric_ord, RIGHTARG = public.{{prefix}}_numeric_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql index 7b0b3b19b..092a57f9c 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_numeric_ord_ore. +--! @brief Functions for {{prefix}}.query_numeric_ord_ore. ---! @brief Index extractor for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_numeric_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_numeric_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a public.eql_v3_numeric_ord_ore ---! @param b eql_v3.query_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a public.{{prefix}}_numeric_ord_ore +--! @param b {{prefix}}.query_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_numeric_ord_ore, b eql_v3.query_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_numeric_ord_ore, b {{prefix}}.query_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_numeric_ord_ore. ---! @param a eql_v3.query_numeric_ord_ore ---! @param b public.eql_v3_numeric_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_numeric_ord_ore. +--! @param a {{prefix}}.query_numeric_ord_ore +--! @param b public.{{prefix}}_numeric_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.eql_v3_numeric_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_numeric_ord_ore, b public.{{prefix}}_numeric_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql index 0147b7351..b9d1959cc 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql --! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_numeric_ord_ore. +--! @brief Operators for {{prefix}}.query_numeric_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_numeric_ord_ore, RIGHTARG = {{prefix}}.query_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.eql_v3_numeric_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_numeric_ord_ore, RIGHTARG = public.{{prefix}}_numeric_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql b/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql index 96c9aa9b4..b9646bcf8 100644 --- a/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql +++ b/packages/eql/src/v3/scalars/numeric/query_numeric_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/numeric/query_numeric_types.sql --! @brief Query-operand domains for numeric (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_numeric_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_numeric_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_numeric_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_numeric_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_numeric_eq IS 'EQL numeric query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_numeric_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_numeric_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_numeric_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_numeric_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_numeric_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_numeric_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_numeric_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_numeric_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_numeric_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/ore_fallback.sql b/packages/eql/src/v3/scalars/ore_fallback.sql index 993af2e32..ce56a258a 100644 --- a/packages/eql/src/v3/scalars/ore_fallback.sql +++ b/packages/eql/src/v3/scalars/ore_fallback.sql @@ -25,14 +25,14 @@ --! --! Runs after the DO block in src/v3/sem/ore_block_256/operator_class.sql, --! which ATTEMPTS to create the default btree operator class for ---! eql_v3_internal.ore_block_256 and skips it on insufficient_privilege +--! {{prefix}}_internal.ore_block_256 and skips it on insufficient_privilege --! (CREATE OPERATOR CLASS requires superuser; managed platforms — cloud --! Supabase and most hosted Postgres — run the installer as a non-superuser --! role). When the class was created, this file is a no-op. --! --! When the class was skipped, the ORE-carrying domains would otherwise --! install half-working: `<`/`>` comparisons still run (as unindexable seq ---! scans), while `CREATE INDEX ... (eql_v3.ord_term(col))` and bare +--! scans), while `CREATE INDEX ... ({{prefix}}.ord_term(col))` and bare --! `ORDER BY` fail with opaque Postgres errors. Instead of that silent --! degradation, this file poisons every ORE-carrying domain (and its --! query-operand twin) with an always-raising CHECK constraint, so the first @@ -62,7 +62,7 @@ BEGIN JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod WHERE am.amname = 'btree' AND c.opcdefault - AND c.opcintype = 'eql_v3_internal.ore_block_256'::pg_catalog.regtype + AND c.opcintype = '{{prefix}}_internal.ore_block_256'::pg_catalog.regtype ) THEN RETURN; END IF; @@ -70,7 +70,7 @@ BEGIN --! @brief Poison CHECK backing for the ORE-carrying domains on platforms --! without the ORE operator class. Always raises; never returns. --! @internal - CREATE FUNCTION eql_v3_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text) + CREATE FUNCTION {{prefix}}_internal.ore_domain_unavailable(val jsonb, domain_name text, alternatives text) RETURNS boolean IMMUTABLE PARALLEL SAFE SET search_path = pg_catalog, extensions, public @@ -87,65 +87,65 @@ BEGIN -- must not abort). Domain coercion still enforces the CHECK on every new -- cast/insert regardless of validation status. - ALTER DOMAIN public.eql_v3_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_integer_ord_ore', 'public.eql_v3_integer_eq (equality) or public.eql_v3_integer_ord (ordering) or public.eql_v3_integer_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_integer_ord_ore', 'public.{{prefix}}_integer_eq (equality) or public.{{prefix}}_integer_ord (ordering) or public.{{prefix}}_integer_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_integer_ord_ore', 'eql_v3.query_integer_eq (equality) or eql_v3.query_integer_ord (ordering) or eql_v3.query_integer_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_integer_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_integer_ord_ore', '{{prefix}}.query_integer_eq (equality) or {{prefix}}.query_integer_ord (ordering) or {{prefix}}.query_integer_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_smallint_ord_ore', 'public.eql_v3_smallint_eq (equality) or public.eql_v3_smallint_ord (ordering) or public.eql_v3_smallint_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_smallint_ord_ore', 'public.{{prefix}}_smallint_eq (equality) or public.{{prefix}}_smallint_ord (ordering) or public.{{prefix}}_smallint_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_smallint_ord_ore', 'eql_v3.query_smallint_eq (equality) or eql_v3.query_smallint_ord (ordering) or eql_v3.query_smallint_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_smallint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_smallint_ord_ore', '{{prefix}}.query_smallint_eq (equality) or {{prefix}}.query_smallint_ord (ordering) or {{prefix}}.query_smallint_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_bigint_ord_ore', 'public.eql_v3_bigint_eq (equality) or public.eql_v3_bigint_ord (ordering) or public.eql_v3_bigint_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_bigint_ord_ore', 'public.{{prefix}}_bigint_eq (equality) or public.{{prefix}}_bigint_ord (ordering) or public.{{prefix}}_bigint_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_bigint_ord_ore', 'eql_v3.query_bigint_eq (equality) or eql_v3.query_bigint_ord (ordering) or eql_v3.query_bigint_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_bigint_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_bigint_ord_ore', '{{prefix}}.query_bigint_eq (equality) or {{prefix}}.query_bigint_ord (ordering) or {{prefix}}.query_bigint_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_date_ord_ore', 'public.eql_v3_date_eq (equality) or public.eql_v3_date_ord (ordering) or public.eql_v3_date_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_date_ord_ore', 'public.{{prefix}}_date_eq (equality) or public.{{prefix}}_date_ord (ordering) or public.{{prefix}}_date_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_date_ord_ore', 'eql_v3.query_date_eq (equality) or eql_v3.query_date_ord (ordering) or eql_v3.query_date_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_date_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_date_ord_ore', '{{prefix}}.query_date_eq (equality) or {{prefix}}.query_date_ord (ordering) or {{prefix}}.query_date_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_timestamp_ord_ore', 'public.eql_v3_timestamp_eq (equality) or public.eql_v3_timestamp_ord (ordering) or public.eql_v3_timestamp_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_timestamp_ord_ore', 'public.{{prefix}}_timestamp_eq (equality) or public.{{prefix}}_timestamp_ord (ordering) or public.{{prefix}}_timestamp_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_timestamp_ord_ore', 'eql_v3.query_timestamp_eq (equality) or eql_v3.query_timestamp_ord (ordering) or eql_v3.query_timestamp_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_timestamp_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_timestamp_ord_ore', '{{prefix}}.query_timestamp_eq (equality) or {{prefix}}.query_timestamp_ord (ordering) or {{prefix}}.query_timestamp_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_numeric_ord_ore', 'public.eql_v3_numeric_eq (equality) or public.eql_v3_numeric_ord (ordering) or public.eql_v3_numeric_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_numeric_ord_ore', 'public.{{prefix}}_numeric_eq (equality) or public.{{prefix}}_numeric_ord (ordering) or public.{{prefix}}_numeric_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_numeric_ord_ore', 'eql_v3.query_numeric_eq (equality) or eql_v3.query_numeric_ord (ordering) or eql_v3.query_numeric_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_numeric_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_numeric_ord_ore', '{{prefix}}.query_numeric_eq (equality) or {{prefix}}.query_numeric_ord (ordering) or {{prefix}}.query_numeric_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_ord_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_text_ord_ore', 'public.{{prefix}}_text_eq (equality) or public.{{prefix}}_text_match (match) or public.{{prefix}}_text_ord (ordering) or public.{{prefix}}_text_ord_ope (ordering) or public.{{prefix}}_text_search (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_ord_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_text_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_text_ord_ore', '{{prefix}}.query_text_eq (equality) or {{prefix}}.query_text_match (match) or {{prefix}}.query_text_ord (ordering) or {{prefix}}.query_text_ord_ope (ordering) or {{prefix}}.query_text_search (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_text_search_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_text_search_ore', 'public.eql_v3_text_eq (equality) or public.eql_v3_text_match (match) or public.eql_v3_text_ord (ordering) or public.eql_v3_text_ord_ope (ordering) or public.eql_v3_text_search (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_text_search_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_text_search_ore', 'public.{{prefix}}_text_eq (equality) or public.{{prefix}}_text_match (match) or public.{{prefix}}_text_ord (ordering) or public.{{prefix}}_text_ord_ope (ordering) or public.{{prefix}}_text_search (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_text_search_ore', 'eql_v3.query_text_eq (equality) or eql_v3.query_text_match (match) or eql_v3.query_text_ord (ordering) or eql_v3.query_text_ord_ope (ordering) or eql_v3.query_text_search (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_text_search_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_text_search_ore', '{{prefix}}.query_text_eq (equality) or {{prefix}}.query_text_match (match) or {{prefix}}.query_text_ord (ordering) or {{prefix}}.query_text_ord_ope (ordering) or {{prefix}}.query_text_search (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_real_ord_ore', 'public.eql_v3_real_eq (equality) or public.eql_v3_real_ord (ordering) or public.eql_v3_real_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_real_ord_ore', 'public.{{prefix}}_real_eq (equality) or public.{{prefix}}_real_ord (ordering) or public.{{prefix}}_real_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_real_ord_ore', 'eql_v3.query_real_eq (equality) or eql_v3.query_real_ord (ordering) or eql_v3.query_real_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_real_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_real_ord_ore', '{{prefix}}.query_real_eq (equality) or {{prefix}}.query_real_ord (ordering) or {{prefix}}.query_real_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN public.eql_v3_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'public.eql_v3_double_ord_ore', 'public.eql_v3_double_eq (equality) or public.eql_v3_double_ord (ordering) or public.eql_v3_double_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN public.{{prefix}}_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, 'public.{{prefix}}_double_ord_ore', 'public.{{prefix}}_double_eq (equality) or public.{{prefix}}_double_ord (ordering) or public.{{prefix}}_double_ord_ope (ordering)')) NOT VALID; - ALTER DOMAIN eql_v3.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable - CHECK (eql_v3_internal.ore_domain_unavailable(VALUE, 'eql_v3.query_double_ord_ore', 'eql_v3.query_double_eq (equality) or eql_v3.query_double_ord (ordering) or eql_v3.query_double_ord_ope (ordering)')) NOT VALID; + ALTER DOMAIN {{prefix}}.query_double_ord_ore ADD CONSTRAINT eql_ore_unavailable + CHECK ({{prefix}}_internal.ore_domain_unavailable(VALUE, '{{prefix}}.query_double_ord_ore', '{{prefix}}.query_double_eq (equality) or {{prefix}}.query_double_ord (ordering) or {{prefix}}.query_double_ord_ope (ordering)')) NOT VALID; RAISE NOTICE 'EQL: ORE operator class absent (creation requires superuser) — 20 ORE-backed domains disabled and will raise on use; use the _ord_ope (ordering) and _eq (equality) domains — and text_match for text pattern match — instead'; END; diff --git a/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql b/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql index 2493cab90..6cab30901 100644 --- a/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql +++ b/packages/eql/src/v3/scalars/real/json_entry_real_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/real/query_real_ord_ope_functions.sql --! @file encrypted_domain/real/json_entry_real_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_real_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_real_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql b/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql index 2fcdc8691..4ddcc8522 100644 --- a/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql +++ b/packages/eql/src/v3/scalars/real/json_entry_real_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/real/json_entry_real_functions.sql --! @file encrypted_domain/real/json_entry_real_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql b/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql index cacb702cc..637bd5045 100644 --- a/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql +++ b/packages/eql/src/v3/scalars/real/query_real_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/real/real_eq_functions.sql --! @file encrypted_domain/real/query_real_eq_functions.sql ---! @brief Functions for eql_v3.query_real_eq. +--! @brief Functions for {{prefix}}.query_real_eq. ---! @brief Index extractor for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_real_eq. +--! @param a {{prefix}}.query_real_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_real_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq +--! @brief Operator wrapper for {{prefix}}.query_real_eq. +--! @param a public.{{prefix}}_real_eq +--! @param b {{prefix}}.query_real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b {{prefix}}.query_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for {{prefix}}.query_real_eq. +--! @param a {{prefix}}.query_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b eql_v3.query_real_eq +--! @brief Operator wrapper for {{prefix}}.query_real_eq. +--! @param a public.{{prefix}}_real_eq +--! @param b {{prefix}}.query_real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b eql_v3.query_real_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b {{prefix}}.query_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_eq. ---! @param a eql_v3.query_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for {{prefix}}.query_real_eq. +--! @param a {{prefix}}.query_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql b/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql index 00ba0dfe6..340424f44 100644 --- a/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql +++ b/packages/eql/src/v3/scalars/real/query_real_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/real/query_real_eq_functions.sql --! @file encrypted_domain/real/query_real_eq_operators.sql ---! @brief Operators for eql_v3.query_real_eq. +--! @brief Operators for {{prefix}}.query_real_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = {{prefix}}.query_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_real_eq, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = eql_v3.query_real_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = {{prefix}}.query_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_real_eq, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql index 8ca85ec93..b1292e6e4 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/real/real_ord_functions.sql --! @file encrypted_domain/real/query_real_ord_functions.sql ---! @brief Functions for eql_v3.query_real_ord. +--! @brief Functions for {{prefix}}.query_real_ord. ---! @brief Index extractor for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_real_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b eql_v3.query_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b {{prefix}}.query_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b eql_v3.query_real_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b {{prefix}}.query_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord. ---! @param a eql_v3.query_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for {{prefix}}.query_real_ord. +--! @param a {{prefix}}.query_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql index 4bc7d3b16..6e71401ea 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ope_functions.sql --! @file encrypted_domain/real/query_real_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ope. +--! @brief Functions for {{prefix}}.query_real_ord_ope. ---! @brief Index extractor for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_real_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b eql_v3.query_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b {{prefix}}.query_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b eql_v3.query_real_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b {{prefix}}.query_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ope. ---! @param a eql_v3.query_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ope. +--! @param a {{prefix}}.query_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql index de0c9606d..b8b13b85e 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/real/query_real_ord_ope_functions.sql --! @file encrypted_domain/real/query_real_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ope. +--! @brief Operators for {{prefix}}.query_real_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = {{prefix}}.query_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql index 2859bc840..6ae884957 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/real/query_real_ord_functions.sql --! @file encrypted_domain/real/query_real_ord_operators.sql ---! @brief Operators for eql_v3.query_real_ord. +--! @brief Operators for {{prefix}}.query_real_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = eql_v3.query_real_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = {{prefix}}.query_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql index 82aedde96..db512dd9a 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ore_functions.sql --! @file encrypted_domain/real/query_real_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_real_ord_ore. +--! @brief Functions for {{prefix}}.query_real_ord_ore. ---! @brief Index extractor for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_real_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b eql_v3.query_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b {{prefix}}.query_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b eql_v3.query_real_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b {{prefix}}.query_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_real_ord_ore. ---! @param a eql_v3.query_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_real_ord_ore. +--! @param a {{prefix}}.query_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql b/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql index c7d56e1dc..8e8d624d8 100644 --- a/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/real/query_real_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/real/query_real_ord_ore_functions.sql --! @file encrypted_domain/real/query_real_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_real_ord_ore. +--! @brief Operators for {{prefix}}.query_real_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = {{prefix}}.query_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/real/query_real_types.sql b/packages/eql/src/v3/scalars/real/query_real_types.sql index 57ed840bc..a7b81b073 100644 --- a/packages/eql/src/v3/scalars/real/query_real_types.sql +++ b/packages/eql/src/v3/scalars/real/query_real_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/real/query_real_types.sql --! @brief Query-operand domains for real (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_real_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_real_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_real_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_real_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_real_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_real_eq IS 'EQL real query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_real_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_real_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_real_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_real_ord_ore IS 'EQL real query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_real_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_real_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_real_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_real_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_real_ord IS 'EQL real query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_real_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_real_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_real_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_real_ord_ope IS 'EQL real query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/real/real_eq_functions.sql b/packages/eql/src/v3/scalars/real/real_eq_functions.sql index a7b504d59..382829281 100644 --- a/packages/eql/src/v3/scalars/real/real_eq_functions.sql +++ b/packages/eql/src/v3/scalars/real/real_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/real/real_eq_functions.sql ---! @brief Functions for public.eql_v3_real_eq. +--! @brief Functions for public.{{prefix}}_real_eq. ---! @brief Index extractor for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_real_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_real_eq. +--! @param a public.{{prefix}}_real_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_real_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.{{prefix}}_real_eq. +--! @param a public.{{prefix}}_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.{{prefix}}_real_eq. +--! @param a public.{{prefix}}_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_real_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.{{prefix}}_real_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_real_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq ---! @param b public.eql_v3_real_eq +--! @brief Operator wrapper for public.{{prefix}}_real_eq. +--! @param a public.{{prefix}}_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. ---! @param a public.eql_v3_real_eq +--! @brief Operator wrapper for public.{{prefix}}_real_eq. +--! @param a public.{{prefix}}_real_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_real_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_real_eq) $$; ---! @brief Operator wrapper for public.eql_v3_real_eq. +--! @brief Operator wrapper for public.{{prefix}}_real_eq. --! @param a jsonb ---! @param b public.eql_v3_real_eq +--! @param b public.{{prefix}}_real_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_real_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_real_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector text) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_eq, selector text) +RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_eq, selector integer) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_eq, selector integer) +RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_eq right operand of the blocked operator ---! @return public.eql_v3_real_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_eq) -RETURNS public.eql_v3_real_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_eq'; END; $$ +--! @param selector public.{{prefix}}_real_eq right operand of the blocked operator +--! @return public.{{prefix}}_real_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_eq) +RETURNS public.{{prefix}}_real_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_real_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_eq, b public.{{prefix}}_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_eq left operand of the blocked operator +--! @param a public.{{prefix}}_real_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_eq right operand of the blocked operator +--! @param b public.{{prefix}}_real_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/real/real_eq_operators.sql b/packages/eql/src/v3/scalars/real/real_eq_operators.sql index 9ddac1035..a5c06a230 100644 --- a/packages/eql/src/v3/scalars/real/real_eq_operators.sql +++ b/packages/eql/src/v3/scalars/real/real_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/real/real_eq_functions.sql --! @file encrypted_domain/real/real_eq_operators.sql ---! @brief Operators for public.eql_v3_real_eq. +--! @brief Operators for public.{{prefix}}_real_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = public.{{prefix}}_real_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_eq ); diff --git a/packages/eql/src/v3/scalars/real/real_functions.sql b/packages/eql/src/v3/scalars/real/real_functions.sql index 2d68e57ca..dbcfe5b47 100644 --- a/packages/eql/src/v3/scalars/real/real_functions.sql +++ b/packages/eql/src/v3/scalars/real/real_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/real/real_functions.sql ---! @brief Functions for public.eql_v3_real. +--! @brief Functions for public.{{prefix}}_real. ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_real never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector text) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real, selector text) +RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_real never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real, selector integer) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real, selector integer) +RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real right operand of the blocked operator ---! @return public.eql_v3_real never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real) -RETURNS public.eql_v3_real IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real'; END; $$ +--! @param selector public.{{prefix}}_real right operand of the blocked operator +--! @return public.{{prefix}}_real never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real) +RETURNS public.{{prefix}}_real IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real right operand of the blocked operator +--! @param selector public.{{prefix}}_real right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real, b public.{{prefix}}_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real left operand of the blocked operator +--! @param a public.{{prefix}}_real left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real. +--! @brief Unsupported operator blocker for public.{{prefix}}_real. --! ---! Intercepts an operator that is not supported on public.eql_v3_real and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real right operand of the blocked operator +--! @param b public.{{prefix}}_real right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/real/real_operators.sql b/packages/eql/src/v3/scalars/real/real_operators.sql index 99ed1e23d..f03c820e5 100644 --- a/packages/eql/src/v3/scalars/real/real_operators.sql +++ b/packages/eql/src/v3/scalars/real/real_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/real/real_functions.sql --! @file encrypted_domain/real/real_operators.sql ---! @brief Operators for public.eql_v3_real. +--! @brief Operators for public.{{prefix}}_real. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_real, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real, RIGHTARG = public.{{prefix}}_real ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql index 608c7f7f0..cb43ea23b 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/real/real_ord_operators.sql --! @file encrypted_domain/real/real_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord. +--! @brief Aggregates for public.{{prefix}}_real_ord. ---! @brief State function for min on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord +--! @brief State function for min on public.{{prefix}}_real_ord. +--! @param state public.{{prefix}}_real_ord +--! @param value public.{{prefix}}_real_ord +--! @return public.{{prefix}}_real_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord, value public.{{prefix}}_real_ord) +RETURNS public.{{prefix}}_real_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_real_ord. +--! @param input public.{{prefix}}_real_ord +--! @return public.{{prefix}}_real_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_real_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_real_ord. ---! @param state public.eql_v3_real_ord ---! @param value public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord, value public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord +--! @brief State function for max on public.{{prefix}}_real_ord. +--! @param state public.{{prefix}}_real_ord +--! @param value public.{{prefix}}_real_ord +--! @return public.{{prefix}}_real_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord, value public.{{prefix}}_real_ord) +RETURNS public.{{prefix}}_real_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_real_ord. ---! @param input public.eql_v3_real_ord ---! @return public.eql_v3_real_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_real_ord. +--! @param input public.{{prefix}}_real_ord +--! @return public.{{prefix}}_real_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_real_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_functions.sql index e3631653b..2b54c4312 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_functions.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/real/real_ord_functions.sql ---! @brief Functions for public.eql_v3_real_ord. +--! @brief Functions for public.{{prefix}}_real_ord. ---! @brief Index extractor for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_real_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord ---! @param b public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. ---! @param a public.eql_v3_real_ord +--! @brief Operator wrapper for public.{{prefix}}_real_ord. +--! @param a public.{{prefix}}_real_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord. +--! @brief Operator wrapper for public.{{prefix}}_real_ord. --! @param a jsonb ---! @param b public.eql_v3_real_ord +--! @param b public.{{prefix}}_real_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector text) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord, selector text) +RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord, selector integer) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord, selector integer) +RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord right operand of the blocked operator ---! @return public.eql_v3_real_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord) -RETURNS public.eql_v3_real_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord'; END; $$ +--! @param selector public.{{prefix}}_real_ord right operand of the blocked operator +--! @return public.{{prefix}}_real_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord) +RETURNS public.{{prefix}}_real_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_real_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord, b public.{{prefix}}_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql index de285158c..ec99c5f40 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ope_operators.sql --! @file encrypted_domain/real/real_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ope. +--! @brief Aggregates for public.{{prefix}}_real_ord_ope. ---! @brief State function for min on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope +--! @brief State function for min on public.{{prefix}}_real_ord_ope. +--! @param state public.{{prefix}}_real_ord_ope +--! @param value public.{{prefix}}_real_ord_ope +--! @return public.{{prefix}}_real_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord_ope, value public.{{prefix}}_real_ord_ope) +RETURNS public.{{prefix}}_real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_real_ord_ope. +--! @param input public.{{prefix}}_real_ord_ope +--! @return public.{{prefix}}_real_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_real_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_real_ord_ope. ---! @param state public.eql_v3_real_ord_ope ---! @param value public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ope, value public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope +--! @brief State function for max on public.{{prefix}}_real_ord_ope. +--! @param state public.{{prefix}}_real_ord_ope +--! @param value public.{{prefix}}_real_ord_ope +--! @return public.{{prefix}}_real_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord_ope, value public.{{prefix}}_real_ord_ope) +RETURNS public.{{prefix}}_real_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_real_ord_ope. ---! @param input public.eql_v3_real_ord_ope ---! @return public.eql_v3_real_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_real_ord_ope. +--! @param input public.{{prefix}}_real_ord_ope +--! @return public.{{prefix}}_real_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_real_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql index 18da5b294..7143e3fa6 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/real/real_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ope. +--! @brief Functions for public.{{prefix}}_real_ord_ope. ---! @brief Index extractor for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_real_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_real_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope ---! @param b public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. ---! @param a public.eql_v3_real_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. +--! @param a public.{{prefix}}_real_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_real_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_real_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ope +--! @param b public.{{prefix}}_real_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_real_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_real_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector text) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ope, selector text) +RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ope, selector integer) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ope, selector integer) +RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator ---! @return public.eql_v3_real_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ope) -RETURNS public.eql_v3_real_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_real_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_real_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord_ope) +RETURNS public.{{prefix}}_real_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ope, b public.{{prefix}}_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql index c11db40a3..310f1264b 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ope_functions.sql --! @file encrypted_domain/real/real_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ope. +--! @brief Operators for public.{{prefix}}_real_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = public.{{prefix}}_real_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ope ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_operators.sql index b5b3692b1..922e70ab4 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_operators.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/real/real_ord_functions.sql --! @file encrypted_domain/real/real_ord_operators.sql ---! @brief Operators for public.eql_v3_real_ord. +--! @brief Operators for public.{{prefix}}_real_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = public.{{prefix}}_real_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql index 60abf7116..e9708bacb 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ore_operators.sql --! @file encrypted_domain/real/real_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_real_ord_ore. +--! @brief Aggregates for public.{{prefix}}_real_ord_ore. ---! @brief State function for min on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore +--! @brief State function for min on public.{{prefix}}_real_ord_ore. +--! @param state public.{{prefix}}_real_ord_ore +--! @param value public.{{prefix}}_real_ord_ore +--! @return public.{{prefix}}_real_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_real_ord_ore, value public.{{prefix}}_real_ord_ore) +RETURNS public.{{prefix}}_real_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_real_ord_ore. +--! @param input public.{{prefix}}_real_ord_ore +--! @return public.{{prefix}}_real_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_real_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_real_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_real_ord_ore. ---! @param state public.eql_v3_real_ord_ore ---! @param value public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_real_ord_ore, value public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore +--! @brief State function for max on public.{{prefix}}_real_ord_ore. +--! @param state public.{{prefix}}_real_ord_ore +--! @param value public.{{prefix}}_real_ord_ore +--! @return public.{{prefix}}_real_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_real_ord_ore, value public.{{prefix}}_real_ord_ore) +RETURNS public.{{prefix}}_real_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_real_ord_ore. ---! @param input public.eql_v3_real_ord_ore ---! @return public.eql_v3_real_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_real_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_real_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_real_ord_ore. +--! @param input public.{{prefix}}_real_ord_ore +--! @return public.{{prefix}}_real_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_real_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_real_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql index bbc01055f..c88e2b5b9 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/real/real_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_real_ord_ore. +--! @brief Functions for public.{{prefix}}_real_ord_ore. ---! @brief Index extractor for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_real_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_real_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore ---! @param b public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. ---! @param a public.eql_v3_real_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. +--! @param a public.{{prefix}}_real_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_real_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_real_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_real_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_real_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_real_ord_ore +--! @param b public.{{prefix}}_real_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_real_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_real_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector text) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ore, selector text) +RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_real_ord_ore, selector integer) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_real_ord_ore, selector integer) +RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator ---! @return public.eql_v3_real_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_real_ord_ore) -RETURNS public.eql_v3_real_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_real_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_real_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_real_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_real_ord_ore) +RETURNS public.{{prefix}}_real_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_real_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_real_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_real_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_real_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_real_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_real_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_real_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_real_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ore, b public.{{prefix}}_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_real_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_real_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_real_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_real_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_real_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_real_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_real_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_real_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_real_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_real_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_real_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_real_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_real_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql b/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql index bb5fb6d9e..5702adba4 100644 --- a/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/real/real_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/real/real_ord_ore_functions.sql --! @file encrypted_domain/real/real_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_real_ord_ore. +--! @brief Operators for public.{{prefix}}_real_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = public.{{prefix}}_real_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_real_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_real_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_real_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_real_ord_ore ); diff --git a/packages/eql/src/v3/scalars/real/real_types.sql b/packages/eql/src/v3/scalars/real/real_types.sql index 94087d16d..186fe4d4f 100644 --- a/packages/eql/src/v3/scalars/real/real_types.sql +++ b/packages/eql/src/v3/scalars/real/real_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_real. + --! @brief Encrypted domain public.{{prefix}}_real. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_real' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real AS jsonb + CREATE DOMAIN public.{{prefix}}_real AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_real IS 'EQL encrypted real (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_real IS 'EQL encrypted real (storage only)'; - --! @brief Encrypted domain public.eql_v3_real_eq. + --! @brief Encrypted domain public.{{prefix}}_real_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_real_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_real_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_eq IS 'EQL encrypted real (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_real_eq IS 'EQL encrypted real (equality)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_real_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_real_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_real_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_real_ord_ore IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord. + --! @brief Encrypted domain public.{{prefix}}_real_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_real_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_real_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_real_ord IS 'EQL encrypted real (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_real_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_real_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_real_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_real_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_real_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_real_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_real_ord_ope IS 'EQL encrypted real (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql index 6d6a55848..44fd8e299 100644 --- a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_functions.sql @@ -7,244 +7,244 @@ -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql --! @file encrypted_domain/smallint/json_entry_smallint_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql index 3ccb0894d..81ba7ff66 100644 --- a/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/json_entry_smallint_operators.sql @@ -5,140 +5,140 @@ -- REQUIRE: src/v3/scalars/smallint/json_entry_smallint_functions.sql --! @file encrypted_domain/smallint/json_entry_smallint_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql index b41e5b564..15357ca4a 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_eq_functions.sql --! @file encrypted_domain/smallint/query_smallint_eq_functions.sql ---! @brief Functions for eql_v3.query_smallint_eq. +--! @brief Functions for {{prefix}}.query_smallint_eq. ---! @brief Index extractor for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_smallint_eq. +--! @param a {{prefix}}.query_smallint_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_smallint_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq +--! @brief Operator wrapper for {{prefix}}.query_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq +--! @param b {{prefix}}.query_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b {{prefix}}.query_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for {{prefix}}.query_smallint_eq. +--! @param a {{prefix}}.query_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b eql_v3.query_smallint_eq +--! @brief Operator wrapper for {{prefix}}.query_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq +--! @param b {{prefix}}.query_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b eql_v3.query_smallint_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b {{prefix}}.query_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_eq. ---! @param a eql_v3.query_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for {{prefix}}.query_smallint_eq. +--! @param a {{prefix}}.query_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql index c85625f7b..1d91a489c 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/smallint/query_smallint_eq_functions.sql --! @file encrypted_domain/smallint/query_smallint_eq_operators.sql ---! @brief Operators for eql_v3.query_smallint_eq. +--! @brief Operators for {{prefix}}.query_smallint_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = {{prefix}}.query_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = eql_v3.query_smallint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = {{prefix}}.query_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql index 21a1d8f7c..59d9eda07 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord. +--! @brief Functions for {{prefix}}.query_smallint_ord. ---! @brief Index extractor for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_smallint_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b eql_v3.query_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b {{prefix}}.query_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b eql_v3.query_smallint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b {{prefix}}.query_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord. ---! @param a eql_v3.query_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord. +--! @param a {{prefix}}.query_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql index 00dc12361..0b14e0831 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ope. +--! @brief Functions for {{prefix}}.query_smallint_ord_ope. ---! @brief Index extractor for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_smallint_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b eql_v3.query_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b {{prefix}}.query_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b eql_v3.query_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b {{prefix}}.query_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ope. ---! @param a eql_v3.query_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ope. +--! @param a {{prefix}}.query_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql index 1b8480f2e..0f37d5b4e 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ope. +--! @brief Operators for {{prefix}}.query_smallint_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = {{prefix}}.query_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql index 5f66128fc..73dc194f7 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord. +--! @brief Operators for {{prefix}}.query_smallint_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = eql_v3.query_smallint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = {{prefix}}.query_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql index b85135a3c..8d898cf4a 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_smallint_ord_ore. +--! @brief Functions for {{prefix}}.query_smallint_ord_ore. ---! @brief Index extractor for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_smallint_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b eql_v3.query_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b {{prefix}}.query_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b eql_v3.query_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b {{prefix}}.query_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_smallint_ord_ore. ---! @param a eql_v3.query_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_smallint_ord_ore. +--! @param a {{prefix}}.query_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql index d71111770..85bccdbf8 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql --! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_smallint_ord_ore. +--! @brief Operators for {{prefix}}.query_smallint_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = {{prefix}}.query_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql b/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql index d2c4a334a..382dc375f 100644 --- a/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql +++ b/packages/eql/src/v3/scalars/smallint/query_smallint_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/smallint/query_smallint_types.sql --! @brief Query-operand domains for smallint (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_smallint_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_smallint_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_smallint_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_smallint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_smallint_eq IS 'EQL smallint query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_smallint_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_smallint_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_smallint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_smallint_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_smallint_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_smallint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_smallint_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_smallint_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_smallint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql index 3721f5af3..ec5cf4911 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/smallint/smallint_eq_functions.sql ---! @brief Functions for public.eql_v3_smallint_eq. +--! @brief Functions for public.{{prefix}}_smallint_eq. ---! @brief Index extractor for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_smallint_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_smallint_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_smallint_eq) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_smallint_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq ---! @param b public.eql_v3_smallint_eq +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. ---! @param a public.eql_v3_smallint_eq +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. +--! @param a public.{{prefix}}_smallint_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_smallint_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_smallint_eq) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_eq. +--! @brief Operator wrapper for public.{{prefix}}_smallint_eq. --! @param a jsonb ---! @param b public.eql_v3_smallint_eq +--! @param b public.{{prefix}}_smallint_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_smallint_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_smallint_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector text) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_eq, selector text) +RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_eq, selector integer) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_eq, selector integer) +RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_eq right operand of the blocked operator ---! @return public.eql_v3_smallint_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_eq) -RETURNS public.eql_v3_smallint_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_eq'; END; $$ +--! @param selector public.{{prefix}}_smallint_eq right operand of the blocked operator +--! @return public.{{prefix}}_smallint_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_eq) +RETURNS public.{{prefix}}_smallint_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_eq, b public.{{prefix}}_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_eq left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_eq right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql index d69ab9fa8..2cbc24904 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_eq_functions.sql --! @file encrypted_domain/smallint/smallint_eq_operators.sql ---! @brief Operators for public.eql_v3_smallint_eq. +--! @brief Operators for public.{{prefix}}_smallint_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = public.{{prefix}}_smallint_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_eq ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_functions.sql index 3423c9a39..9f6e5462f 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/smallint/smallint_functions.sql ---! @brief Functions for public.eql_v3_smallint. +--! @brief Functions for public.{{prefix}}_smallint. ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector text) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ +--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint, selector text) +RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint, selector integer) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ +--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint, selector integer) +RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint right operand of the blocked operator ---! @return public.eql_v3_smallint never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint) -RETURNS public.eql_v3_smallint IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint'; END; $$ +--! @param selector public.{{prefix}}_smallint right operand of the blocked operator +--! @return public.{{prefix}}_smallint never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint) +RETURNS public.{{prefix}}_smallint IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint right operand of the blocked operator +--! @param selector public.{{prefix}}_smallint right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint, b public.{{prefix}}_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint left operand of the blocked operator +--! @param a public.{{prefix}}_smallint left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint right operand of the blocked operator +--! @param b public.{{prefix}}_smallint right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_operators.sql index b249a6835..a05eb5038 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_functions.sql --! @file encrypted_domain/smallint/smallint_operators.sql ---! @brief Operators for public.eql_v3_smallint. +--! @brief Operators for public.{{prefix}}_smallint. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = public.{{prefix}}_smallint ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql index d5b3b6bc3..b9806af5a 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_operators.sql --! @file encrypted_domain/smallint/smallint_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord. +--! @brief Aggregates for public.{{prefix}}_smallint_ord. ---! @brief State function for min on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for min on public.{{prefix}}_smallint_ord. +--! @param state public.{{prefix}}_smallint_ord +--! @param value public.{{prefix}}_smallint_ord +--! @return public.{{prefix}}_smallint_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord, value public.{{prefix}}_smallint_ord) +RETURNS public.{{prefix}}_smallint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_smallint_ord. +--! @param input public.{{prefix}}_smallint_ord +--! @return public.{{prefix}}_smallint_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_smallint_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord. ---! @param state public.eql_v3_smallint_ord ---! @param value public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord, value public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord +--! @brief State function for max on public.{{prefix}}_smallint_ord. +--! @param state public.{{prefix}}_smallint_ord +--! @param value public.{{prefix}}_smallint_ord +--! @return public.{{prefix}}_smallint_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord, value public.{{prefix}}_smallint_ord) +RETURNS public.{{prefix}}_smallint_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord. ---! @param input public.eql_v3_smallint_ord ---! @return public.eql_v3_smallint_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_smallint_ord. +--! @param input public.{{prefix}}_smallint_ord +--! @return public.{{prefix}}_smallint_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_smallint_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql index 705a8556c..973876d47 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/smallint/smallint_ord_functions.sql ---! @brief Functions for public.eql_v3_smallint_ord. +--! @brief Functions for public.{{prefix}}_smallint_ord. ---! @brief Index extractor for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_smallint_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord ---! @param b public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. ---! @param a public.eql_v3_smallint_ord +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. +--! @param a public.{{prefix}}_smallint_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord +--! @param b public.{{prefix}}_smallint_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector text) -RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ +--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord, selector text) +RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord, selector integer) -RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ +--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord, selector integer) +RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord right operand of the blocked operator ---! @return public.eql_v3_smallint_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord) -RETURNS public.eql_v3_smallint_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord'; END; $$ +--! @param selector public.{{prefix}}_smallint_ord right operand of the blocked operator +--! @return public.{{prefix}}_smallint_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord) +RETURNS public.{{prefix}}_smallint_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord, b public.{{prefix}}_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql index 2798573b8..dbb9bed18 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_operators.sql --! @file encrypted_domain/smallint/smallint_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ope. +--! @brief Aggregates for public.{{prefix}}_smallint_ord_ope. ---! @brief State function for min on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for min on public.{{prefix}}_smallint_ord_ope. +--! @param state public.{{prefix}}_smallint_ord_ope +--! @param value public.{{prefix}}_smallint_ord_ope +--! @return public.{{prefix}}_smallint_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord_ope, value public.{{prefix}}_smallint_ord_ope) +RETURNS public.{{prefix}}_smallint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_smallint_ord_ope. +--! @param input public.{{prefix}}_smallint_ord_ope +--! @return public.{{prefix}}_smallint_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_smallint_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord_ope. ---! @param state public.eql_v3_smallint_ord_ope ---! @param value public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ope, value public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope +--! @brief State function for max on public.{{prefix}}_smallint_ord_ope. +--! @param state public.{{prefix}}_smallint_ord_ope +--! @param value public.{{prefix}}_smallint_ord_ope +--! @return public.{{prefix}}_smallint_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord_ope, value public.{{prefix}}_smallint_ord_ope) +RETURNS public.{{prefix}}_smallint_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord_ope. ---! @param input public.eql_v3_smallint_ord_ope ---! @return public.eql_v3_smallint_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_smallint_ord_ope. +--! @param input public.{{prefix}}_smallint_ord_ope +--! @return public.{{prefix}}_smallint_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_smallint_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql index 307f01c0f..0c1d4ee14 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/smallint/smallint_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_smallint_ord_ope. +--! @brief Functions for public.{{prefix}}_smallint_ord_ope. ---! @brief Index extractor for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_smallint_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_smallint_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope ---! @param b public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. ---! @param a public.eql_v3_smallint_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. +--! @param a public.{{prefix}}_smallint_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_smallint_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_smallint_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ope +--! @param b public.{{prefix}}_smallint_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_smallint_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_smallint_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector text) -RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ +--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ope, selector text) +RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ope, selector integer) -RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ +--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ope, selector integer) +RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ope) -RETURNS public.eql_v3_smallint_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_smallint_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_smallint_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord_ope) +RETURNS public.{{prefix}}_smallint_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ope, b public.{{prefix}}_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql index 3f45121ed..826c80e22 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_functions.sql --! @file encrypted_domain/smallint/smallint_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ope. +--! @brief Operators for public.{{prefix}}_smallint_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ope ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql index b5efb730c..8de4d09bc 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_functions.sql --! @file encrypted_domain/smallint/smallint_ord_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord. +--! @brief Operators for public.{{prefix}}_smallint_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = public.{{prefix}}_smallint_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql index e59ea3bdd..491699a6f 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_operators.sql --! @file encrypted_domain/smallint/smallint_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_smallint_ord_ore. +--! @brief Aggregates for public.{{prefix}}_smallint_ord_ore. ---! @brief State function for min on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore +--! @brief State function for min on public.{{prefix}}_smallint_ord_ore. +--! @param state public.{{prefix}}_smallint_ord_ore +--! @param value public.{{prefix}}_smallint_ord_ore +--! @return public.{{prefix}}_smallint_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_smallint_ord_ore, value public.{{prefix}}_smallint_ord_ore) +RETURNS public.{{prefix}}_smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_smallint_ord_ore. +--! @param input public.{{prefix}}_smallint_ord_ore +--! @return public.{{prefix}}_smallint_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_smallint_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_smallint_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_smallint_ord_ore. ---! @param state public.eql_v3_smallint_ord_ore ---! @param value public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_smallint_ord_ore, value public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore +--! @brief State function for max on public.{{prefix}}_smallint_ord_ore. +--! @param state public.{{prefix}}_smallint_ord_ore +--! @param value public.{{prefix}}_smallint_ord_ore +--! @return public.{{prefix}}_smallint_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_smallint_ord_ore, value public.{{prefix}}_smallint_ord_ore) +RETURNS public.{{prefix}}_smallint_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_smallint_ord_ore. ---! @param input public.eql_v3_smallint_ord_ore ---! @return public.eql_v3_smallint_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_smallint_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_smallint_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_smallint_ord_ore. +--! @param input public.{{prefix}}_smallint_ord_ore +--! @return public.{{prefix}}_smallint_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_smallint_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_smallint_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql index ae14169f0..4940f690f 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/smallint/smallint_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_smallint_ord_ore. +--! @brief Functions for public.{{prefix}}_smallint_ord_ore. ---! @brief Index extractor for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_smallint_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_smallint_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore ---! @param b public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. ---! @param a public.eql_v3_smallint_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. +--! @param a public.{{prefix}}_smallint_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_smallint_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_smallint_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_smallint_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_smallint_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_smallint_ord_ore +--! @param b public.{{prefix}}_smallint_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_smallint_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_smallint_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector text) -RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ +--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ore, selector text) +RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_smallint_ord_ore, selector integer) -RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ +--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_smallint_ord_ore, selector integer) +RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator ---! @return public.eql_v3_smallint_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_smallint_ord_ore) -RETURNS public.eql_v3_smallint_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_smallint_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_smallint_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_smallint_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_smallint_ord_ore) +RETURNS public.{{prefix}}_smallint_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_smallint_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_smallint_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_smallint_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_smallint_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_smallint_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_smallint_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_smallint_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_smallint_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_smallint_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_smallint_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ore, b public.{{prefix}}_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_smallint_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_smallint_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_smallint_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_smallint_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_smallint_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_smallint_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_smallint_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_smallint_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_smallint_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_smallint_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_smallint_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql index 602a85417..694f2b2a8 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_functions.sql --! @file encrypted_domain/smallint/smallint_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_smallint_ord_ore. +--! @brief Operators for public.{{prefix}}_smallint_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_smallint_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_smallint_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_smallint_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_smallint_ord_ore ); diff --git a/packages/eql/src/v3/scalars/smallint/smallint_types.sql b/packages/eql/src/v3/scalars/smallint/smallint_types.sql index 8a4044a86..adc4887ca 100644 --- a/packages/eql/src/v3/scalars/smallint/smallint_types.sql +++ b/packages/eql/src/v3/scalars/smallint/smallint_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_smallint. + --! @brief Encrypted domain public.{{prefix}}_smallint. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_smallint' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint AS jsonb + CREATE DOMAIN public.{{prefix}}_smallint AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint IS 'EQL encrypted smallint (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_smallint IS 'EQL encrypted smallint (storage only)'; - --! @brief Encrypted domain public.eql_v3_smallint_eq. + --! @brief Encrypted domain public.{{prefix}}_smallint_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_smallint_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_smallint_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_eq IS 'EQL encrypted smallint (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_smallint_eq IS 'EQL encrypted smallint (equality)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_smallint_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_smallint_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_smallint_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_smallint_ord_ore IS 'EQL encrypted smallint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord. + --! @brief Encrypted domain public.{{prefix}}_smallint_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_smallint_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_smallint_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_smallint_ord IS 'EQL encrypted smallint (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_smallint_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_smallint_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_smallint_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_smallint_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_smallint_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_smallint_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_smallint_ord_ope IS 'EQL encrypted smallint (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql b/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql index 054e48c7a..57c5d45bc 100644 --- a/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql +++ b/packages/eql/src/v3/scalars/text/json_entry_text_functions.sql @@ -7,412 +7,412 @@ -- REQUIRE: src/v3/scalars/text/query_text_ord_ope_functions.sql --! @file encrypted_domain/text/json_entry_text_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a public.eql_v3_json_entry ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a public.{{prefix}}_json_entry +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_json_entry. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_json_entry +--! @brief Operator wrapper for public.{{prefix}}_json_entry. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_json_entry --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_text_search left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_text_search, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql b/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql index 4f98a385b..029d55e8c 100644 --- a/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql +++ b/packages/eql/src/v3/scalars/text/json_entry_text_operators.sql @@ -5,200 +5,200 @@ -- REQUIRE: src/v3/scalars/text/json_entry_text_functions.sql --! @file encrypted_domain/text/json_entry_text_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_json_entry, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_text_search ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_json_entry ); diff --git a/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql b/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql index d0c0cc2e9..0e6260a19 100644 --- a/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/text/text_eq_functions.sql --! @file encrypted_domain/text/query_text_eq_functions.sql ---! @brief Functions for eql_v3.query_text_eq. +--! @brief Functions for {{prefix}}.query_text_eq. ---! @brief Index extractor for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_eq. +--! @param a {{prefix}}.query_text_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq +--! @brief Operator wrapper for {{prefix}}.query_text_eq. +--! @param a public.{{prefix}}_text_eq +--! @param b {{prefix}}.query_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b {{prefix}}.query_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for {{prefix}}.query_text_eq. +--! @param a {{prefix}}.query_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b eql_v3.query_text_eq +--! @brief Operator wrapper for {{prefix}}.query_text_eq. +--! @param a public.{{prefix}}_text_eq +--! @param b {{prefix}}.query_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b eql_v3.query_text_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b {{prefix}}.query_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_eq. ---! @param a eql_v3.query_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for {{prefix}}.query_text_eq. +--! @param a {{prefix}}.query_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql b/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql index 912b0c0c4..08ad73c9c 100644 --- a/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/text/query_text_eq_functions.sql --! @file encrypted_domain/text/query_text_eq_operators.sql ---! @brief Operators for eql_v3.query_text_eq. +--! @brief Operators for {{prefix}}.query_text_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = {{prefix}}.query_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_eq, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = eql_v3.query_text_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = {{prefix}}.query_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_eq, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_match_functions.sql b/packages/eql/src/v3/scalars/text/query_text_match_functions.sql index 21d85ed57..e877edf21 100644 --- a/packages/eql/src/v3/scalars/text/query_text_match_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_match_functions.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/text/text_match_functions.sql --! @file encrypted_domain/text/query_text_match_functions.sql ---! @brief Functions for eql_v3.query_text_match. +--! @brief Functions for {{prefix}}.query_text_match. ---! @brief Index extractor for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for {{prefix}}.query_text_match. +--! @param a {{prefix}}.query_text_match +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_match) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a public.eql_v3_text_match ---! @param b eql_v3.query_text_match +--! @brief Operator wrapper for {{prefix}}.query_text_match. +--! @param a public.{{prefix}}_text_match +--! @param b {{prefix}}.query_text_match --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b eql_v3.query_text_match) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b {{prefix}}.query_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for eql_v3.query_text_match. ---! @param a eql_v3.query_text_match ---! @param b public.eql_v3_text_match +--! @brief Operator wrapper for {{prefix}}.query_text_match. +--! @param a {{prefix}}.query_text_match +--! @param b public.{{prefix}}_text_match --! @return boolean -CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_match, b public.{{prefix}}_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_match_operators.sql b/packages/eql/src/v3/scalars/text/query_text_match_operators.sql index 8a510552d..91dc013b8 100644 --- a/packages/eql/src/v3/scalars/text/query_text_match_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_match_operators.sql @@ -4,16 +4,16 @@ -- REQUIRE: src/v3/scalars/text/query_text_match_functions.sql --! @file encrypted_domain/text/query_text_match_operators.sql ---! @brief Operators for eql_v3.query_text_match. +--! @brief Operators for {{prefix}}.query_text_match. CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = {{prefix}}.query_text_match, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match, + FUNCTION = {{prefix}}.matches, + LEFTARG = {{prefix}}.query_text_match, RIGHTARG = public.{{prefix}}_text_match, RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql index d2c1b932e..e54be6f50 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_functions.sql @@ -4,116 +4,116 @@ -- REQUIRE: src/v3/scalars/text/text_ord_functions.sql --! @file encrypted_domain/text/query_text_ord_functions.sql ---! @brief Functions for eql_v3.query_text_ord. +--! @brief Functions for {{prefix}}.query_text_ord. ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b eql_v3.query_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b {{prefix}}.query_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b eql_v3.query_text_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b {{prefix}}.query_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord. ---! @param a eql_v3.query_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for {{prefix}}.query_text_ord. +--! @param a {{prefix}}.query_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql index 7a111d47d..6ddd10e43 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_ope_functions.sql @@ -4,116 +4,116 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ope_functions.sql --! @file encrypted_domain/text/query_text_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ope. +--! @brief Functions for {{prefix}}.query_text_ord_ope. ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord_ope) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b eql_v3.query_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b {{prefix}}.query_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b eql_v3.query_text_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b {{prefix}}.query_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ope. ---! @param a eql_v3.query_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ope. +--! @param a {{prefix}}.query_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql index 50f68e8b7..2e15e64d4 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/text/query_text_ord_ope_functions.sql --! @file encrypted_domain/text/query_text_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ope. +--! @brief Operators for {{prefix}}.query_text_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = {{prefix}}.query_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql index 0e7d9be4b..8313a604a 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/text/query_text_ord_functions.sql --! @file encrypted_domain/text/query_text_ord_operators.sql ---! @brief Operators for eql_v3.query_text_ord. +--! @brief Operators for {{prefix}}.query_text_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = eql_v3.query_text_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = {{prefix}}.query_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql index d790a4396..f0f4b99f2 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_ore_functions.sql @@ -4,116 +4,116 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ore_functions.sql --! @file encrypted_domain/text/query_text_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_text_ord_ore. +--! @brief Functions for {{prefix}}.query_text_ord_ore. ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_ord_ore) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_text_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b eql_v3.query_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b {{prefix}}.query_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b eql_v3.query_text_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b {{prefix}}.query_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_ord_ore. ---! @param a eql_v3.query_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_text_ord_ore. +--! @param a {{prefix}}.query_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql b/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql index a7526f6f9..52d75e747 100644 --- a/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/text/query_text_ord_ore_functions.sql --! @file encrypted_domain/text/query_text_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_text_ord_ore. +--! @brief Operators for {{prefix}}.query_text_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = {{prefix}}.query_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_search_functions.sql b/packages/eql/src/v3/scalars/text/query_text_search_functions.sql index c5f472ac1..0bc6d563b 100644 --- a/packages/eql/src/v3/scalars/text/query_text_search_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_search_functions.sql @@ -4,140 +4,140 @@ -- REQUIRE: src/v3/scalars/text/text_search_functions.sql --! @file encrypted_domain/text/query_text_search_functions.sql ---! @brief Functions for eql_v3.query_text_search. +--! @brief Functions for {{prefix}}.query_text_search. ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_search) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_text_search) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_search) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a public.eql_v3_text_search ---! @param b eql_v3.query_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b {{prefix}}.query_text_search --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b eql_v3.query_text_search) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b {{prefix}}.query_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for eql_v3.query_text_search. ---! @param a eql_v3.query_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for {{prefix}}.query_text_search. +--! @param a {{prefix}}.query_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_search_operators.sql b/packages/eql/src/v3/scalars/text/query_text_search_operators.sql index 6a5502c37..546618c7e 100644 --- a/packages/eql/src/v3/scalars/text/query_text_search_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_search_operators.sql @@ -4,88 +4,88 @@ -- REQUIRE: src/v3/scalars/text/query_text_search_functions.sql --! @file encrypted_domain/text/query_text_search_operators.sql ---! @brief Operators for eql_v3.query_text_search. +--! @brief Operators for {{prefix}}.query_text_search. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = {{prefix}}.query_text_search, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.matches, + LEFTARG = {{prefix}}.query_text_search, RIGHTARG = public.{{prefix}}_text_search, RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql b/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql index 205a47be1..4f1f4e94a 100644 --- a/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql +++ b/packages/eql/src/v3/scalars/text/query_text_search_ore_functions.sql @@ -4,140 +4,140 @@ -- REQUIRE: src/v3/scalars/text/text_search_ore_functions.sql --! @file encrypted_domain/text/query_text_search_ore_functions.sql ---! @brief Functions for eql_v3.query_text_search_ore. +--! @brief Functions for {{prefix}}.query_text_search_ore. ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_text_search_ore) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_text_search_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Index extractor for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search_ore) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a {{prefix}}.query_text_search_ore) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b eql_v3.query_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b {{prefix}}.query_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b {{prefix}}.query_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for eql_v3.query_text_search_ore. ---! @param a eql_v3.query_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for {{prefix}}.query_text_search_ore. +--! @param a {{prefix}}.query_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.matches(a {{prefix}}.query_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; diff --git a/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql b/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql index 0a78693fe..1d148ee5f 100644 --- a/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql +++ b/packages/eql/src/v3/scalars/text/query_text_search_ore_operators.sql @@ -4,88 +4,88 @@ -- REQUIRE: src/v3/scalars/text/query_text_search_ore_functions.sql --! @file encrypted_domain/text/query_text_search_ore_operators.sql ---! @brief Operators for eql_v3.query_text_search_ore. +--! @brief Operators for {{prefix}}.query_text_search_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = {{prefix}}.query_text_search_ore, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.matches, + LEFTARG = {{prefix}}.query_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, RESTRICT = contsel, JOIN = contjoinsel ); diff --git a/packages/eql/src/v3/scalars/text/query_text_types.sql b/packages/eql/src/v3/scalars/text/query_text_types.sql index eec1a886e..9360a9fbf 100644 --- a/packages/eql/src/v3/scalars/text/query_text_types.sql +++ b/packages/eql/src/v3/scalars/text/query_text_types.sql @@ -3,59 +3,59 @@ --! @file v3/scalars/text/query_text_types.sql --! @brief Query-operand domains for text (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_text_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_text_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_text_eq IS 'EQL text query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_match (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_match' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_match AS jsonb + CREATE DOMAIN {{prefix}}.query_text_match AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'bf' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (matching)'; + COMMENT ON DOMAIN {{prefix}}.query_text_match IS 'EQL text query operand (matching)'; - --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_text_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -65,18 +65,18 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_text_ord_ore IS 'EQL text query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_text_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -84,18 +84,18 @@ BEGIN AND VALUE ? 'hm' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_text_ord IS 'EQL text query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_text_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -103,18 +103,18 @@ BEGIN AND VALUE ? 'hm' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_text_ord_ope IS 'EQL text query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_text_search_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_search_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_search_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_search_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_search_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_text_search_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -125,18 +125,18 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)'; + COMMENT ON DOMAIN {{prefix}}.query_text_search_ore IS 'EQL text query operand (equality, ordering, matching)'; - --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_text_search (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_text_search' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_text_search AS jsonb + CREATE DOMAIN {{prefix}}.query_text_search AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -145,10 +145,10 @@ BEGIN AND VALUE ? 'op' AND VALUE ? 'bf' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, matching)'; + COMMENT ON DOMAIN {{prefix}}.query_text_search IS 'EQL text query operand (equality, ordering, matching)'; END $$; diff --git a/packages/eql/src/v3/scalars/text/text_eq_functions.sql b/packages/eql/src/v3/scalars/text/text_eq_functions.sql index 2bdd95fcf..bbdc0441f 100644 --- a/packages/eql/src/v3/scalars/text/text_eq_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/text/text_eq_functions.sql ---! @brief Functions for public.eql_v3_text_eq. +--! @brief Functions for public.{{prefix}}_text_eq. ---! @brief Index extractor for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_eq. +--! @param a public.{{prefix}}_text_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.{{prefix}}_text_eq. +--! @param a public.{{prefix}}_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.{{prefix}}_text_eq. +--! @param a public.{{prefix}}_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_eq) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.{{prefix}}_text_eq. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq ---! @param b public.eql_v3_text_eq +--! @brief Operator wrapper for public.{{prefix}}_text_eq. +--! @param a public.{{prefix}}_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. ---! @param a public.eql_v3_text_eq +--! @brief Operator wrapper for public.{{prefix}}_text_eq. +--! @param a public.{{prefix}}_text_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_eq) $$; ---! @brief Operator wrapper for public.eql_v3_text_eq. +--! @brief Operator wrapper for public.{{prefix}}_text_eq. --! @param a jsonb ---! @param b public.eql_v3_text_eq +--! @param b public.{{prefix}}_text_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector text) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_eq, selector text) +RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_eq, selector integer) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_eq, selector integer) +RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_eq right operand of the blocked operator ---! @return public.eql_v3_text_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_eq) -RETURNS public.eql_v3_text_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_eq'; END; $$ +--! @param selector public.{{prefix}}_text_eq right operand of the blocked operator +--! @return public.{{prefix}}_text_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_eq) +RETURNS public.{{prefix}}_text_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_text_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_eq, b public.{{prefix}}_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_eq left operand of the blocked operator +--! @param a public.{{prefix}}_text_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_eq right operand of the blocked operator +--! @param b public.{{prefix}}_text_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_eq_operators.sql b/packages/eql/src/v3/scalars/text/text_eq_operators.sql index b58d0ade5..de57e0ae8 100644 --- a/packages/eql/src/v3/scalars/text/text_eq_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/text/text_eq_functions.sql --! @file encrypted_domain/text/text_eq_operators.sql ---! @brief Operators for public.eql_v3_text_eq. +--! @brief Operators for public.{{prefix}}_text_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = public.{{prefix}}_text_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_eq ); diff --git a/packages/eql/src/v3/scalars/text/text_functions.sql b/packages/eql/src/v3/scalars/text/text_functions.sql index 6a4e06dae..e6047c1fa 100644 --- a/packages/eql/src/v3/scalars/text/text_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/text/text_functions.sql ---! @brief Functions for public.eql_v3_text. +--! @brief Functions for public.{{prefix}}_text. ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text, selector text) +RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text, selector integer) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text, selector integer) +RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text right operand of the blocked operator ---! @return public.eql_v3_text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text) -RETURNS public.eql_v3_text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text'; END; $$ +--! @param selector public.{{prefix}}_text right operand of the blocked operator +--! @return public.{{prefix}}_text never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text) +RETURNS public.{{prefix}}_text IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text right operand of the blocked operator +--! @param selector public.{{prefix}}_text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text, b public.{{prefix}}_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text left operand of the blocked operator +--! @param a public.{{prefix}}_text left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text. +--! @brief Unsupported operator blocker for public.{{prefix}}_text. --! ---! Intercepts an operator that is not supported on public.eql_v3_text and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text right operand of the blocked operator +--! @param b public.{{prefix}}_text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_match_functions.sql b/packages/eql/src/v3/scalars/text/text_match_functions.sql index 9005ad5ba..a89752611 100644 --- a/packages/eql/src/v3/scalars/text/text_match_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_match_functions.sql @@ -5,652 +5,652 @@ -- REQUIRE: src/v3/sem/bloom_filter/functions.sql --! @file encrypted_domain/text/text_match_functions.sql ---! @brief Functions for public.eql_v3_text_match. +--! @brief Functions for public.{{prefix}}_text_match. ---! @brief Index extractor for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_match) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for public.{{prefix}}_text_match. +--! @param a public.{{prefix}}_text_match +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_match) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector text) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_match, selector text) +RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_match, selector integer) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_match, selector integer) +RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_match right operand of the blocked operator ---! @return public.eql_v3_text_match never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_match) -RETURNS public.eql_v3_text_match IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_match'; END; $$ +--! @param selector public.{{prefix}}_text_match right operand of the blocked operator +--! @return public.{{prefix}}_text_match never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_match) +RETURNS public.{{prefix}}_text_match IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_match, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_match, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_match, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_match right operand of the blocked operator +--! @param selector public.{{prefix}}_text_match right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_match) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_match, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_match, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_match, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match ---! @param b public.eql_v3_text_match +--! @brief Operator wrapper for public.{{prefix}}_text_match. +--! @param a public.{{prefix}}_text_match +--! @param b public.{{prefix}}_text_match --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_match. ---! @param a public.eql_v3_text_match +--! @brief Operator wrapper for public.{{prefix}}_text_match. +--! @param a public.{{prefix}}_text_match --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_match, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_match) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_match)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_match. +--! @brief Operator wrapper for public.{{prefix}}_text_match. --! @param a jsonb ---! @param b public.eql_v3_text_match +--! @param b public.{{prefix}}_text_match --! @return boolean -CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_match) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_match) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_match)) = 0) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_match, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_match, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_match, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_match, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_match, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_match, b public.{{prefix}}_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_match left operand of the blocked operator +--! @param a public.{{prefix}}_text_match left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_match, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_match, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_match. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_match. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_match and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_match right operand of the blocked operator +--! @param b public.{{prefix}}_text_match right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_match) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_match) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_match'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_match'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_match_operators.sql b/packages/eql/src/v3/scalars/text/text_match_operators.sql index 8f8bae19c..3a8bd4553 100644 --- a/packages/eql/src/v3/scalars/text/text_match_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_match_operators.sql @@ -4,242 +4,242 @@ -- REQUIRE: src/v3/scalars/text/text_match_functions.sql --! @file encrypted_domain/text/text_match_operators.sql ---! @brief Operators for public.eql_v3_text_match. +--! @brief Operators for public.{{prefix}}_text_match. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match, + FUNCTION = {{prefix}}.matches, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_match, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = public.{{prefix}}_text_match ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_match, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_match ); diff --git a/packages/eql/src/v3/scalars/text/text_operators.sql b/packages/eql/src/v3/scalars/text/text_operators.sql index 73c967969..649d86b9e 100644 --- a/packages/eql/src/v3/scalars/text/text_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/text/text_functions.sql --! @file encrypted_domain/text/text_operators.sql ---! @brief Operators for public.eql_v3_text. +--! @brief Operators for public.{{prefix}}_text. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text, RIGHTARG = public.{{prefix}}_text ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql index b73708a46..996be49d3 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/text/text_ord_operators.sql --! @file encrypted_domain/text/text_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord. +--! @brief Aggregates for public.{{prefix}}_text_ord. ---! @brief State function for min on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for min on public.{{prefix}}_text_ord. +--! @param state public.{{prefix}}_text_ord +--! @param value public.{{prefix}}_text_ord +--! @return public.{{prefix}}_text_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord, value public.{{prefix}}_text_ord) +RETURNS public.{{prefix}}_text_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_text_ord. +--! @param input public.{{prefix}}_text_ord +--! @return public.{{prefix}}_text_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_text_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord. ---! @param state public.eql_v3_text_ord ---! @param value public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord, value public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord +--! @brief State function for max on public.{{prefix}}_text_ord. +--! @param state public.{{prefix}}_text_ord +--! @param value public.{{prefix}}_text_ord +--! @return public.{{prefix}}_text_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord, value public.{{prefix}}_text_ord) +RETURNS public.{{prefix}}_text_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord. ---! @param input public.eql_v3_text_ord ---! @return public.eql_v3_text_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_text_ord. +--! @param input public.{{prefix}}_text_ord +--! @return public.{{prefix}}_text_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_text_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_functions.sql index b8257790c..afd8d5e8c 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_functions.sql @@ -6,570 +6,570 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/text/text_ord_functions.sql ---! @brief Functions for public.eql_v3_text_ord. +--! @brief Functions for public.{{prefix}}_text_ord. ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord ---! @param b public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. ---! @param a public.eql_v3_text_ord +--! @brief Operator wrapper for public.{{prefix}}_text_ord. +--! @param a public.{{prefix}}_text_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord. +--! @brief Operator wrapper for public.{{prefix}}_text_ord. --! @param a jsonb ---! @param b public.eql_v3_text_ord +--! @param b public.{{prefix}}_text_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector text) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord, selector text) +RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord, selector integer) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord, selector integer) +RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord right operand of the blocked operator ---! @return public.eql_v3_text_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord) -RETURNS public.eql_v3_text_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord'; END; $$ +--! @param selector public.{{prefix}}_text_ord right operand of the blocked operator +--! @return public.{{prefix}}_text_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord) +RETURNS public.{{prefix}}_text_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_text_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord, b public.{{prefix}}_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql index 1508bbb48..c7e436d00 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ope_operators.sql --! @file encrypted_domain/text/text_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ope. +--! @brief Aggregates for public.{{prefix}}_text_ord_ope. ---! @brief State function for min on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for min on public.{{prefix}}_text_ord_ope. +--! @param state public.{{prefix}}_text_ord_ope +--! @param value public.{{prefix}}_text_ord_ope +--! @return public.{{prefix}}_text_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord_ope, value public.{{prefix}}_text_ord_ope) +RETURNS public.{{prefix}}_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_text_ord_ope. +--! @param input public.{{prefix}}_text_ord_ope +--! @return public.{{prefix}}_text_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_text_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord_ope. ---! @param state public.eql_v3_text_ord_ope ---! @param value public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ope, value public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope +--! @brief State function for max on public.{{prefix}}_text_ord_ope. +--! @param state public.{{prefix}}_text_ord_ope +--! @param value public.{{prefix}}_text_ord_ope +--! @return public.{{prefix}}_text_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord_ope, value public.{{prefix}}_text_ord_ope) +RETURNS public.{{prefix}}_text_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord_ope. ---! @param input public.eql_v3_text_ord_ope ---! @return public.eql_v3_text_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_text_ord_ope. +--! @param input public.{{prefix}}_text_ord_ope +--! @return public.{{prefix}}_text_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_text_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql index a2b05930f..6a3566036 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ope_functions.sql @@ -6,570 +6,570 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/text/text_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ope. +--! @brief Functions for public.{{prefix}}_text_ord_ope. ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ope) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord_ope) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ope) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ope) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ope) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope ---! @param b public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. ---! @param a public.eql_v3_text_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. +--! @param a public.{{prefix}}_text_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ope +--! @param b public.{{prefix}}_text_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector text) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ope, selector text) +RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ope, selector integer) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ope, selector integer) +RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator ---! @return public.eql_v3_text_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ope) -RETURNS public.eql_v3_text_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_text_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_text_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord_ope) +RETURNS public.{{prefix}}_text_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ope, b public.{{prefix}}_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql index 90609b417..cba59dbf4 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ope_functions.sql --! @file encrypted_domain/text/text_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ope. +--! @brief Operators for public.{{prefix}}_text_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = public.{{prefix}}_text_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ope ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_operators.sql index bbfceaeec..b371ea398 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/text/text_ord_functions.sql --! @file encrypted_domain/text/text_ord_operators.sql ---! @brief Operators for public.eql_v3_text_ord. +--! @brief Operators for public.{{prefix}}_text_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = public.{{prefix}}_text_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql index cf4628582..be2e574b8 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ore_operators.sql --! @file encrypted_domain/text/text_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_ord_ore. +--! @brief Aggregates for public.{{prefix}}_text_ord_ore. ---! @brief State function for min on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore +--! @brief State function for min on public.{{prefix}}_text_ord_ore. +--! @param state public.{{prefix}}_text_ord_ore +--! @param value public.{{prefix}}_text_ord_ore +--! @return public.{{prefix}}_text_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_ord_ore, value public.{{prefix}}_text_ord_ore) +RETURNS public.{{prefix}}_text_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_text_ord_ore. +--! @param input public.{{prefix}}_text_ord_ore +--! @return public.{{prefix}}_text_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_text_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_ord_ore. ---! @param state public.eql_v3_text_ord_ore ---! @param value public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_ord_ore, value public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore +--! @brief State function for max on public.{{prefix}}_text_ord_ore. +--! @param state public.{{prefix}}_text_ord_ore +--! @param value public.{{prefix}}_text_ord_ore +--! @return public.{{prefix}}_text_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_ord_ore, value public.{{prefix}}_text_ord_ore) +RETURNS public.{{prefix}}_text_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_ord_ore. ---! @param input public.eql_v3_text_ord_ore ---! @return public.eql_v3_text_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_text_ord_ore. +--! @param input public.{{prefix}}_text_ord_ore +--! @return public.{{prefix}}_text_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_text_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql index f0bae2ed9..d61d16612 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ore_functions.sql @@ -7,570 +7,570 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/text/text_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_text_ord_ore. +--! @brief Functions for public.{{prefix}}_text_ord_ore. ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_ord_ore) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_text_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ore) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_ord_ore) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_ord_ore) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore ---! @param b public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. ---! @param a public.eql_v3_text_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. +--! @param a public.{{prefix}}_text_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_text_ord_ore +--! @param b public.{{prefix}}_text_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector text) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ore, selector text) +RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_ord_ore, selector integer) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_ord_ore, selector integer) +RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator ---! @return public.eql_v3_text_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_ord_ore) -RETURNS public.eql_v3_text_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_text_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_text_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_ord_ore) +RETURNS public.{{prefix}}_text_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ore, b public.{{prefix}}_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql b/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql index bead4d0c1..4a4a9d957 100644 --- a/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/text/text_ord_ore_functions.sql --! @file encrypted_domain/text/text_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_text_ord_ore. +--! @brief Operators for public.{{prefix}}_text_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = public.{{prefix}}_text_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_ord_ore ); diff --git a/packages/eql/src/v3/scalars/text/text_search_aggregates.sql b/packages/eql/src/v3/scalars/text/text_search_aggregates.sql index cd7377420..eb105ee61 100644 --- a/packages/eql/src/v3/scalars/text/text_search_aggregates.sql +++ b/packages/eql/src/v3/scalars/text/text_search_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/text/text_search_operators.sql --! @file encrypted_domain/text/text_search_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search. +--! @brief Aggregates for public.{{prefix}}_text_search. ---! @brief State function for min on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search +--! @brief State function for min on public.{{prefix}}_text_search. +--! @param state public.{{prefix}}_text_search +--! @param value public.{{prefix}}_text_search +--! @return public.{{prefix}}_text_search +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_search, value public.{{prefix}}_text_search) +RETURNS public.{{prefix}}_text_search LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_text_search. +--! @param input public.{{prefix}}_text_search +--! @return public.{{prefix}}_text_search +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_search) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_text_search, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_search. ---! @param state public.eql_v3_text_search ---! @param value public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search, value public.eql_v3_text_search) -RETURNS public.eql_v3_text_search +--! @brief State function for max on public.{{prefix}}_text_search. +--! @param state public.{{prefix}}_text_search +--! @param value public.{{prefix}}_text_search +--! @return public.{{prefix}}_text_search +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_search, value public.{{prefix}}_text_search) +RETURNS public.{{prefix}}_text_search LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_search. ---! @param input public.eql_v3_text_search ---! @return public.eql_v3_text_search -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_text_search. +--! @param input public.{{prefix}}_text_search +--! @return public.{{prefix}}_text_search +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_search) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_text_search, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/text/text_search_functions.sql b/packages/eql/src/v3/scalars/text/text_search_functions.sql index b4cf3f5d2..22dfe9043 100644 --- a/packages/eql/src/v3/scalars/text/text_search_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_search_functions.sql @@ -7,560 +7,560 @@ -- REQUIRE: src/v3/sem/bloom_filter/functions.sql --! @file encrypted_domain/text/text_search_functions.sql ---! @brief Functions for public.eql_v3_text_search. +--! @brief Functions for public.{{prefix}}_text_search. ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_search) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_text_search) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_search) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_text_search) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_text_search) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_text_search) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_text_search) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector text) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search, selector text) +RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search, selector integer) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search, selector integer) +RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_search right operand of the blocked operator ---! @return public.eql_v3_text_search never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search) -RETURNS public.eql_v3_text_search IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search'; END; $$ +--! @param selector public.{{prefix}}_text_search right operand of the blocked operator +--! @return public.{{prefix}}_text_search never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_search) +RETURNS public.{{prefix}}_text_search IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_search right operand of the blocked operator +--! @param selector public.{{prefix}}_text_search right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_search) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_search, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_search, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search ---! @param b public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. ---! @param a public.eql_v3_text_search +--! @brief Operator wrapper for public.{{prefix}}_text_search. +--! @param a public.{{prefix}}_text_search --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_search) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_search)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_search. +--! @brief Operator wrapper for public.{{prefix}}_text_search. --! @param a jsonb ---! @param b public.eql_v3_text_search +--! @param b public.{{prefix}}_text_search --! @return boolean -CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_search) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_search) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_search)) = 0) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_search, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_search, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_search, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search, b public.{{prefix}}_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search left operand of the blocked operator +--! @param a public.{{prefix}}_text_search left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search right operand of the blocked operator +--! @param b public.{{prefix}}_text_search right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_search) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_search_operators.sql b/packages/eql/src/v3/scalars/text/text_search_operators.sql index 68181488c..e335cfc71 100644 --- a/packages/eql/src/v3/scalars/text/text_search_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_search_operators.sql @@ -4,260 +4,260 @@ -- REQUIRE: src/v3/scalars/text/text_search_functions.sql --! @file encrypted_domain/text/text_search_operators.sql ---! @brief Operators for public.eql_v3_text_search. +--! @brief Operators for public.{{prefix}}_text_search. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search, + FUNCTION = {{prefix}}.matches, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = public.{{prefix}}_text_search ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_search, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search ); diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql b/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql index 5204b2f58..0f67b6f9f 100644 --- a/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/text/text_search_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/text/text_search_ore_operators.sql --! @file encrypted_domain/text/text_search_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_text_search_ore. +--! @brief Aggregates for public.{{prefix}}_text_search_ore. ---! @brief State function for min on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore +--! @brief State function for min on public.{{prefix}}_text_search_ore. +--! @param state public.{{prefix}}_text_search_ore +--! @param value public.{{prefix}}_text_search_ore +--! @return public.{{prefix}}_text_search_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_text_search_ore, value public.{{prefix}}_text_search_ore) +RETURNS public.{{prefix}}_text_search_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_text_search_ore. +--! @param input public.{{prefix}}_text_search_ore +--! @return public.{{prefix}}_text_search_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_text_search_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_text_search_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_text_search_ore. ---! @param state public.eql_v3_text_search_ore ---! @param value public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_text_search_ore, value public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore +--! @brief State function for max on public.{{prefix}}_text_search_ore. +--! @param state public.{{prefix}}_text_search_ore +--! @param value public.{{prefix}}_text_search_ore +--! @return public.{{prefix}}_text_search_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_text_search_ore, value public.{{prefix}}_text_search_ore) +RETURNS public.{{prefix}}_text_search_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_text_search_ore. ---! @param input public.eql_v3_text_search_ore ---! @return public.eql_v3_text_search_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_text_search_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_text_search_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_text_search_ore. +--! @param input public.{{prefix}}_text_search_ore +--! @return public.{{prefix}}_text_search_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_text_search_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_text_search_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql b/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql index 60f75a5ed..fb3eaa35d 100644 --- a/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql +++ b/packages/eql/src/v3/scalars/text/text_search_ore_functions.sql @@ -8,560 +8,560 @@ -- REQUIRE: src/v3/sem/bloom_filter/functions.sql --! @file encrypted_domain/text/text_search_ore_functions.sql ---! @brief Functions for public.eql_v3_text_search_ore. +--! @brief Functions for public.{{prefix}}_text_search_ore. ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_text_search_ore) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_text_search_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Index extractor for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @return eql_v3_internal.bloom_filter -CREATE FUNCTION eql_v3.match_term(a public.eql_v3_text_search_ore) -RETURNS eql_v3_internal.bloom_filter +--! @brief Index extractor for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @return {{prefix}}_internal.bloom_filter +CREATE FUNCTION {{prefix}}.match_term(a public.{{prefix}}_text_search_ore) +RETURNS {{prefix}}_internal.bloom_filter LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.bloom_filter(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search_ore) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_text_search_ore) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_text_search_ore) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_text_search_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_text_search_ore) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_text_search_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_text_search_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector text) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search_ore, selector text) +RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_text_search_ore, selector integer) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_text_search_ore, selector integer) +RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_search_ore right operand of the blocked operator ---! @return public.eql_v3_text_search_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_text_search_ore) -RETURNS public.eql_v3_text_search_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_text_search_ore'; END; $$ +--! @param selector public.{{prefix}}_text_search_ore right operand of the blocked operator +--! @return public.{{prefix}}_text_search_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_text_search_ore) +RETURNS public.{{prefix}}_text_search_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_text_search_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_text_search_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_text_search_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_text_search_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_text_search_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore ---! @param b public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. ---! @param a public.eql_v3_text_search_ore +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. +--! @param a public.{{prefix}}_text_search_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.matches(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}.matches(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a) @> {{prefix}}.match_term(b::public.{{prefix}}_text_search_ore) AND (cardinality({{prefix}}.match_term(b::public.{{prefix}}_text_search_ore)) > 0 OR cardinality({{prefix}}.match_term(a)) = 0) $$; ---! @brief Operator wrapper for public.eql_v3_text_search_ore. +--! @brief Operator wrapper for public.{{prefix}}_text_search_ore. --! @param a jsonb ---! @param b public.eql_v3_text_search_ore +--! @param b public.{{prefix}}_text_search_ore --! @return boolean -CREATE FUNCTION eql_v3.matches(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}.matches(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE -AS $$ 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) $$; +AS $$ SELECT {{prefix}}.match_term(a::public.{{prefix}}_text_search_ore) @> {{prefix}}.match_term(b) AND (cardinality({{prefix}}.match_term(b)) > 0 OR cardinality({{prefix}}.match_term(a::public.{{prefix}}_text_search_ore)) = 0) $$; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_text_search_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_text_search_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_text_search_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_text_search_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search_ore, b public.{{prefix}}_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_text_search_ore left operand of the blocked operator +--! @param a public.{{prefix}}_text_search_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_text_search_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_text_search_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_text_search_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_text_search_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_text_search_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_text_search_ore right operand of the blocked operator +--! @param b public.{{prefix}}_text_search_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_text_search_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_text_search_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_text_search_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_text_search_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql b/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql index b1980cc7d..a8d35616d 100644 --- a/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql +++ b/packages/eql/src/v3/scalars/text/text_search_ore_operators.sql @@ -4,260 +4,260 @@ -- REQUIRE: src/v3/scalars/text/text_search_ore_functions.sql --! @file encrypted_domain/text/text_search_ore_operators.sql ---! @brief Operators for public.eql_v3_text_search_ore. +--! @brief Operators for public.{{prefix}}_text_search_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.matches, + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3.matches, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore, + FUNCTION = {{prefix}}.matches, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore, RESTRICT = contsel, JOIN = contjoinsel ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = public.{{prefix}}_text_search_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_text_search_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_text_search_ore ); diff --git a/packages/eql/src/v3/scalars/text/text_types.sql b/packages/eql/src/v3/scalars/text/text_types.sql index 28f2718bb..c4c93d202 100644 --- a/packages/eql/src/v3/scalars/text/text_types.sql +++ b/packages/eql/src/v3/scalars/text/text_types.sql @@ -6,65 +6,65 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_text. + --! @brief Encrypted domain public.{{prefix}}_text. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text AS jsonb + CREATE DOMAIN public.{{prefix}}_text AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text IS 'EQL encrypted text (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_text IS 'EQL encrypted text (storage only)'; - --! @brief Encrypted domain public.eql_v3_text_eq. + --! @brief Encrypted domain public.{{prefix}}_text_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_text_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_eq IS 'EQL encrypted text (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_text_eq IS 'EQL encrypted text (equality)'; - --! @brief Encrypted domain public.eql_v3_text_match. + --! @brief Encrypted domain public.{{prefix}}_text_match. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_match' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_match' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_match AS jsonb + CREATE DOMAIN public.{{prefix}}_text_match AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'bf' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_match IS 'EQL encrypted text (matching)'; + COMMENT ON DOMAIN public.{{prefix}}_text_match IS 'EQL encrypted text (matching)'; - --! @brief Encrypted domain public.eql_v3_text_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_text_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_text_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -74,18 +74,18 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_text_ord_ore IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord. + --! @brief Encrypted domain public.{{prefix}}_text_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_text_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -93,18 +93,18 @@ BEGIN AND VALUE ? 'c' AND VALUE ? 'hm' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_text_ord IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_text_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_text_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -112,18 +112,18 @@ BEGIN AND VALUE ? 'c' AND VALUE ? 'hm' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_text_ord_ope IS 'EQL encrypted text (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_text_search_ore. + --! @brief Encrypted domain public.{{prefix}}_text_search_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_search_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_text_search_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -134,18 +134,18 @@ BEGIN AND VALUE ? 'bf' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)'; + COMMENT ON DOMAIN public.{{prefix}}_text_search_ore IS 'EQL encrypted text (equality, ordering, matching)'; - --! @brief Encrypted domain public.eql_v3_text_search. + --! @brief Encrypted domain public.{{prefix}}_text_search. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_text_search' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_text_search' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_text_search AS jsonb + CREATE DOMAIN public.{{prefix}}_text_search AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -154,10 +154,10 @@ BEGIN AND VALUE ? 'hm' AND VALUE ? 'op' AND VALUE ? 'bf' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_text_search IS 'EQL encrypted text (equality, ordering, matching)'; + COMMENT ON DOMAIN public.{{prefix}}_text_search IS 'EQL encrypted text (equality, ordering, matching)'; END $$; diff --git a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql index 56f32c95a..69d61924d 100644 --- a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_functions.sql @@ -5,340 +5,340 @@ -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql --! @file encrypted_domain/timestamp/json_entry_timestamp_functions.sql ---! @brief Functions for public.eql_v3_json_entry. +--! @brief Functions for public.{{prefix}}_json_entry. ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.eq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.neq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.lte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_json_entry left operand of the blocked operator ---! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_json_entry left operand of the blocked operator +--! @param b {{prefix}}.query_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_json_entry, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_json_entry. +--! @brief Unsupported operator blocker for public.{{prefix}}_json_entry. --! ---! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_json_entry and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_json_entry right operand of the blocked operator +--! @param a {{prefix}}.query_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_json_entry right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry) +CREATE FUNCTION {{prefix}}_internal.gte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_json_entry) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_json_entry'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql index 2da514109..99c06b37e 100644 --- a/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/json_entry_timestamp_operators.sql @@ -5,124 +5,124 @@ -- REQUIRE: src/v3/scalars/timestamp/json_entry_timestamp_functions.sql --! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql ---! @brief Operators for public.eql_v3_json_entry. +--! @brief Operators for public.{{prefix}}_json_entry. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_json_entry, RIGHTARG = {{prefix}}.query_timestamp_ord_ope ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_json_entry ); diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql index 9bee74f0d..9adbce317 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql @@ -4,44 +4,44 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql ---! @brief Functions for eql_v3.query_timestamp_eq. +--! @brief Functions for {{prefix}}.query_timestamp_eq. ---! @brief Index extractor for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for {{prefix}}.query_timestamp_eq. +--! @param a {{prefix}}.query_timestamp_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a {{prefix}}.query_timestamp_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq +--! @param b {{prefix}}.query_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b {{prefix}}.query_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq. +--! @param a {{prefix}}.query_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b eql_v3.query_timestamp_eq +--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq +--! @param b {{prefix}}.query_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b eql_v3.query_timestamp_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b {{prefix}}.query_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_eq. ---! @param a eql_v3.query_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for {{prefix}}.query_timestamp_eq. +--! @param a {{prefix}}.query_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql index 59115cfd1..da1d3981f 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql @@ -4,28 +4,28 @@ -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_eq_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql ---! @brief Operators for eql_v3.query_timestamp_eq. +--! @brief Operators for {{prefix}}.query_timestamp_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = {{prefix}}.query_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = {{prefix}}.query_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql index 4fbc3c5a8..fb15aea1c 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord. +--! @brief Functions for {{prefix}}.query_timestamp_ord. ---! @brief Index extractor for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_timestamp_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b eql_v3.query_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b {{prefix}}.query_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b eql_v3.query_timestamp_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b {{prefix}}.query_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord. ---! @param a eql_v3.query_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord. +--! @param a {{prefix}}.query_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql index 9570cfaa7..a6073f700 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ope. +--! @brief Functions for {{prefix}}.query_timestamp_ord_ope. ---! @brief Index extractor for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a {{prefix}}.query_timestamp_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b eql_v3.query_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b {{prefix}}.query_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b {{prefix}}.query_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope. ---! @param a eql_v3.query_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ope. +--! @param a {{prefix}}.query_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql index bea80edde..5bd5cdd90 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ope. +--! @brief Operators for {{prefix}}.query_timestamp_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = {{prefix}}.query_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql index e8aba6361..303def929 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord. +--! @brief Operators for {{prefix}}.query_timestamp_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = {{prefix}}.query_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql index 41c697170..b081475a3 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql @@ -4,108 +4,108 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql ---! @brief Functions for eql_v3.query_timestamp_ord_ore. +--! @brief Functions for {{prefix}}.query_timestamp_ord_ore. ---! @brief Index extractor for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a eql_v3.query_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a {{prefix}}.query_timestamp_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b eql_v3.query_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b {{prefix}}.query_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b {{prefix}}.query_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore. ---! @param a eql_v3.query_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for {{prefix}}.query_timestamp_ord_ore. +--! @param a {{prefix}}.query_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a {{prefix}}.query_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql index 63a7acda9..13b0cecd9 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql @@ -4,76 +4,76 @@ -- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql --! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql ---! @brief Operators for eql_v3.query_timestamp_ord_ore. +--! @brief Operators for {{prefix}}.query_timestamp_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = {{prefix}}.query_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = {{prefix}}.query_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); diff --git a/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql b/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql index 741e38141..4a9978ee0 100644 --- a/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql +++ b/packages/eql/src/v3/scalars/timestamp/query_timestamp_types.sql @@ -3,41 +3,41 @@ --! @file v3/scalars/timestamp/query_timestamp_types.sql --! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext). ---! @note Query-operand domains live in `eql_v3` (not `public`): they are +--! @note Query-operand domains live in `{{prefix}}` (not `public`): they are --! never valid column types, so they don't belong in the column-type --! namespace, and dropping the EQL-owned schema can never drop an --! application column. --! @note Cast a query operand explicitly to its `query_` domain in a predicate ---! (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare, +--! (e.g. `WHERE col = $1::{{prefix}}.query_timestamp_eq`). A bare, --! uncast literal RHS is ambiguous between the `query_` and `jsonb` --! operator overloads and will not resolve. DO $$ BEGIN - --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_timestamp_eq (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_timestamp_eq' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb + CREATE DOMAIN {{prefix}}.query_timestamp_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'hm' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; + COMMENT ON DOMAIN {{prefix}}.query_timestamp_eq IS 'EQL timestamp query operand (equality)'; - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_timestamp_ord_ore (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb + CREATE DOMAIN {{prefix}}.query_timestamp_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -46,46 +46,46 @@ BEGIN AND NOT (VALUE ? 'c') AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_timestamp_ord (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_timestamp_ord' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb + CREATE DOMAIN {{prefix}}.query_timestamp_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)'; - --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`). + --! @brief Query-operand domain {{prefix}}.query_timestamp_ord_ope (term-only; no `c`). IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace + WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = '{{prefix}}'::regnamespace ) THEN - CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb + CREATE DOMAIN {{prefix}}.query_timestamp_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'op' AND NOT (VALUE ? 'c') - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; + COMMENT ON DOMAIN {{prefix}}.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)'; END $$; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql index c5551cfc4..9ffb046cd 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_functions.sql @@ -5,634 +5,634 @@ -- REQUIRE: src/v3/sem/hmac_256/functions.sql --! @file encrypted_domain/timestamp/timestamp_eq_functions.sql ---! @brief Functions for public.eql_v3_timestamp_eq. +--! @brief Functions for public.{{prefix}}_timestamp_eq. ---! @brief Index extractor for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @return eql_v3_internal.hmac_256 -CREATE FUNCTION eql_v3.eq_term(a public.eql_v3_timestamp_eq) -RETURNS eql_v3_internal.hmac_256 +--! @brief Index extractor for public.{{prefix}}_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq +--! @return {{prefix}}_internal.hmac_256 +CREATE FUNCTION {{prefix}}.eq_term(a public.{{prefix}}_timestamp_eq) +RETURNS {{prefix}}_internal.hmac_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.hmac_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) = {{prefix}}.eq_term(b::public.{{prefix}}_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) = eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_timestamp_eq) = {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq ---! @param b public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. ---! @param a public.eql_v3_timestamp_eq +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. +--! @param a public.{{prefix}}_timestamp_eq --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b::public.eql_v3_timestamp_eq) $$; +AS $$ SELECT {{prefix}}.eq_term(a) <> {{prefix}}.eq_term(b::public.{{prefix}}_timestamp_eq) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_eq. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_eq. --! @param a jsonb ---! @param b public.eql_v3_timestamp_eq +--! @param b public.{{prefix}}_timestamp_eq --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.eq_term(a::public.eql_v3_timestamp_eq) <> eql_v3.eq_term(b) $$; +AS $$ SELECT {{prefix}}.eq_term(a::public.{{prefix}}_timestamp_eq) <> {{prefix}}.eq_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector text) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_eq, selector text) +RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_eq, selector integer) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_eq, selector integer) +RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator ---! @return public.eql_v3_timestamp_eq never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_eq) -RETURNS public.eql_v3_timestamp_eq IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_eq'; END; $$ +--! @param selector public.{{prefix}}_timestamp_eq right operand of the blocked operator +--! @return public.{{prefix}}_timestamp_eq never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_eq) +RETURNS public.{{prefix}}_timestamp_eq IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_eq, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_eq, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_eq, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param selector public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_eq) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_eq, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_eq, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_eq, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_eq, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_eq, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_eq, b public.{{prefix}}_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_eq left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_eq left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_eq, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_eq, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_eq. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_eq. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_eq and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_eq right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_eq right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_eq) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_eq) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_eq'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_eq'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql index f9c344077..def560a45 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_eq_operators.sql @@ -4,245 +4,245 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql --! @file encrypted_domain/timestamp/timestamp_eq_operators.sql ---! @brief Operators for public.eql_v3_timestamp_eq. +--! @brief Operators for public.{{prefix}}_timestamp_eq. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = public.{{prefix}}_timestamp_eq ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_eq, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_eq, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_eq + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_eq ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql index 032d60210..81be42ad0 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_functions.sql @@ -4,662 +4,662 @@ -- REQUIRE: src/v3/scalars/functions.sql --! @file encrypted_domain/timestamp/timestamp_functions.sql ---! @brief Functions for public.eql_v3_timestamp. +--! @brief Functions for public.{{prefix}}_timestamp. ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.eq(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.eq(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.neq(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.neq(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lt(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.lt(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.lte(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.lte(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gt(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.gt(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.gte(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.gte(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector text) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp, selector text) +RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp, selector integer) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp, selector integer) +RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp right operand of the blocked operator ---! @return public.eql_v3_timestamp never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp) -RETURNS public.eql_v3_timestamp IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp'; END; $$ +--! @param selector public.{{prefix}}_timestamp right operand of the blocked operator +--! @return public.{{prefix}}_timestamp never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp) +RETURNS public.{{prefix}}_timestamp IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp right operand of the blocked operator +--! @param selector public.{{prefix}}_timestamp right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp, b public.{{prefix}}_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql index c634ecaa9..5d2be2118 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_operators.sql @@ -4,239 +4,239 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_functions.sql --! @file encrypted_domain/timestamp/timestamp_operators.sql ---! @brief Operators for public.eql_v3_timestamp. +--! @brief Operators for public.{{prefix}}_timestamp. CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR = ( - FUNCTION = eql_v3_internal.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <> ( - FUNCTION = eql_v3_internal.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR < ( - FUNCTION = eql_v3_internal.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <= ( - FUNCTION = eql_v3_internal.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR > ( - FUNCTION = eql_v3_internal.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR >= ( - FUNCTION = eql_v3_internal.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = public.{{prefix}}_timestamp ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql index 4c35aabf1..18676a280 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_operators.sql --! @file encrypted_domain/timestamp/timestamp_ord_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord. +--! @brief Aggregates for public.{{prefix}}_timestamp_ord. ---! @brief State function for min on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for min on public.{{prefix}}_timestamp_ord. +--! @param state public.{{prefix}}_timestamp_ord +--! @param value public.{{prefix}}_timestamp_ord +--! @return public.{{prefix}}_timestamp_ord +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord, value public.{{prefix}}_timestamp_ord) +RETURNS public.{{prefix}}_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_timestamp_ord. +--! @param input public.{{prefix}}_timestamp_ord +--! @return public.{{prefix}}_timestamp_ord +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_timestamp_ord, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_timestamp_ord. ---! @param state public.eql_v3_timestamp_ord ---! @param value public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord, value public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord +--! @brief State function for max on public.{{prefix}}_timestamp_ord. +--! @param state public.{{prefix}}_timestamp_ord +--! @param value public.{{prefix}}_timestamp_ord +--! @return public.{{prefix}}_timestamp_ord +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord, value public.{{prefix}}_timestamp_ord) +RETURNS public.{{prefix}}_timestamp_ord LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_timestamp_ord. ---! @param input public.eql_v3_timestamp_ord ---! @return public.eql_v3_timestamp_ord -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_timestamp_ord. +--! @param input public.{{prefix}}_timestamp_ord +--! @return public.{{prefix}}_timestamp_ord +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_timestamp_ord, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql index 0835181df..d912cf0b9 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/timestamp/timestamp_ord_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord. +--! @brief Functions for public.{{prefix}}_timestamp_ord. ---! @brief Index extractor for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_timestamp_ord) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord ---! @param b public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. ---! @param a public.eql_v3_timestamp_ord +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. +--! @param a public.{{prefix}}_timestamp_ord --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord +--! @param b public.{{prefix}}_timestamp_ord --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector text) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord, selector text) +RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord, selector integer) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord, selector integer) +RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord) -RETURNS public.eql_v3_timestamp_ord IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord'; END; $$ +--! @param selector public.{{prefix}}_timestamp_ord right operand of the blocked operator +--! @return public.{{prefix}}_timestamp_ord never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord) +RETURNS public.{{prefix}}_timestamp_ord IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param selector public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord, b public.{{prefix}}_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql index 3f2e47eba..216e101af 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql --! @file encrypted_domain/timestamp/timestamp_ord_ope_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ope. +--! @brief Aggregates for public.{{prefix}}_timestamp_ord_ope. ---! @brief State function for min on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope +--! @brief State function for min on public.{{prefix}}_timestamp_ord_ope. +--! @param state public.{{prefix}}_timestamp_ord_ope +--! @param value public.{{prefix}}_timestamp_ord_ope +--! @return public.{{prefix}}_timestamp_ord_ope +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord_ope, value public.{{prefix}}_timestamp_ord_ope) +RETURNS public.{{prefix}}_timestamp_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_timestamp_ord_ope. +--! @param input public.{{prefix}}_timestamp_ord_ope +--! @return public.{{prefix}}_timestamp_ord_ope +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord_ope) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_timestamp_ord_ope, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ope. ---! @param state public.eql_v3_timestamp_ord_ope ---! @param value public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ope, value public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope +--! @brief State function for max on public.{{prefix}}_timestamp_ord_ope. +--! @param state public.{{prefix}}_timestamp_ord_ope +--! @param value public.{{prefix}}_timestamp_ord_ope +--! @return public.{{prefix}}_timestamp_ord_ope +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord_ope, value public.{{prefix}}_timestamp_ord_ope) +RETURNS public.{{prefix}}_timestamp_ord_ope LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_timestamp_ord_ope. ---! @param input public.eql_v3_timestamp_ord_ope ---! @return public.eql_v3_timestamp_ord_ope -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ope) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ope, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_timestamp_ord_ope. +--! @param input public.{{prefix}}_timestamp_ord_ope +--! @return public.{{prefix}}_timestamp_ord_ope +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord_ope) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_timestamp_ord_ope, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql index fa9a58797..d62552482 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql @@ -5,562 +5,562 @@ -- REQUIRE: src/v3/sem/ope_cllw/functions.sql --! @file encrypted_domain/timestamp/timestamp_ord_ope_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ope. +--! @brief Functions for public.{{prefix}}_timestamp_ord_ope. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @return eql_v3_internal.ope_cllw -CREATE FUNCTION eql_v3.ord_term(a public.eql_v3_timestamp_ord_ope) -RETURNS eql_v3_internal.ope_cllw +--! @brief Index extractor for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @return {{prefix}}_internal.ope_cllw +CREATE FUNCTION {{prefix}}.ord_term(a public.{{prefix}}_timestamp_ord_ope) +RETURNS {{prefix}}_internal.ope_cllw LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ope_cllw(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) = {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) = eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) = {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <> {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <> eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) <> {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) < {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) < eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) < {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) <= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) <= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) <= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) > {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) > eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) > {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope ---! @param b public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. ---! @param a public.eql_v3_timestamp_ord_ope +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. +--! @param a public.{{prefix}}_timestamp_ord_ope --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b::public.eql_v3_timestamp_ord_ope) $$; +AS $$ SELECT {{prefix}}.ord_term(a) >= {{prefix}}.ord_term(b::public.{{prefix}}_timestamp_ord_ope) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ope. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ope. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ope +--! @param b public.{{prefix}}_timestamp_ord_ope --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term(a::public.eql_v3_timestamp_ord_ope) >= eql_v3.ord_term(b) $$; +AS $$ SELECT {{prefix}}.ord_term(a::public.{{prefix}}_timestamp_ord_ope) >= {{prefix}}.ord_term(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector text) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ope, selector text) +RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ope, selector integer) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ope, selector integer) +RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ope) -RETURNS public.eql_v3_timestamp_ord_ope IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ope'; END; $$ +--! @param selector public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator +--! @return public.{{prefix}}_timestamp_ord_ope never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord_ope) +RETURNS public.{{prefix}}_timestamp_ord_ope IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ope, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ope, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ope, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param selector public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord_ope) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord_ope, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ope, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ope, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ope, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord_ope, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ope, b public.{{prefix}}_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ope left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ope, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ope, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ope. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ope. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ope and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ope right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ope) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord_ope) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ope'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ope'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql index 476e379c6..615cdbea8 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ope_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql --! @file encrypted_domain/timestamp/timestamp_ord_ope_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ope. +--! @brief Operators for public.{{prefix}}_timestamp_ord_ope. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ope, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord_ope, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ope + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ope ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql index 0334ca561..02e9da6df 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_functions.sql --! @file encrypted_domain/timestamp/timestamp_ord_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord. +--! @brief Operators for public.{{prefix}}_timestamp_ord. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = public.{{prefix}}_timestamp_ord ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql index efdfc06b2..014cf2e02 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_aggregates.sql @@ -5,14 +5,14 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql --! @file encrypted_domain/timestamp/timestamp_ord_ore_aggregates.sql ---! @brief Aggregates for public.eql_v3_timestamp_ord_ore. +--! @brief Aggregates for public.{{prefix}}_timestamp_ord_ore. ---! @brief State function for min on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.min_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore +--! @brief State function for min on public.{{prefix}}_timestamp_ord_ore. +--! @param state public.{{prefix}}_timestamp_ord_ore +--! @param value public.{{prefix}}_timestamp_ord_ore +--! @return public.{{prefix}}_timestamp_ord_ore +CREATE FUNCTION {{prefix}}_internal.min_sfunc(state public.{{prefix}}_timestamp_ord_ore, value public.{{prefix}}_timestamp_ord_ore) +RETURNS public.{{prefix}}_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -24,22 +24,22 @@ BEGIN END; $$; ---! @brief min aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.min(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.min_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.min_sfunc, +--! @brief min aggregate for public.{{prefix}}_timestamp_ord_ore. +--! @param input public.{{prefix}}_timestamp_ord_ore +--! @return public.{{prefix}}_timestamp_ord_ore +CREATE AGGREGATE {{prefix}}.min(public.{{prefix}}_timestamp_ord_ore) ( + sfunc = {{prefix}}_internal.min_sfunc, + stype = public.{{prefix}}_timestamp_ord_ore, + combinefunc = {{prefix}}_internal.min_sfunc, parallel = safe ); ---! @brief State function for max on public.eql_v3_timestamp_ord_ore. ---! @param state public.eql_v3_timestamp_ord_ore ---! @param value public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE FUNCTION eql_v3_internal.max_sfunc(state public.eql_v3_timestamp_ord_ore, value public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore +--! @brief State function for max on public.{{prefix}}_timestamp_ord_ore. +--! @param state public.{{prefix}}_timestamp_ord_ore +--! @param value public.{{prefix}}_timestamp_ord_ore +--! @return public.{{prefix}}_timestamp_ord_ore +CREATE FUNCTION {{prefix}}_internal.max_sfunc(state public.{{prefix}}_timestamp_ord_ore, value public.{{prefix}}_timestamp_ord_ore) +RETURNS public.{{prefix}}_timestamp_ord_ore LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE SET search_path = pg_catalog, extensions, public AS $$ @@ -51,12 +51,12 @@ BEGIN END; $$; ---! @brief max aggregate for public.eql_v3_timestamp_ord_ore. ---! @param input public.eql_v3_timestamp_ord_ore ---! @return public.eql_v3_timestamp_ord_ore -CREATE AGGREGATE eql_v3.max(public.eql_v3_timestamp_ord_ore) ( - sfunc = eql_v3_internal.max_sfunc, - stype = public.eql_v3_timestamp_ord_ore, - combinefunc = eql_v3_internal.max_sfunc, +--! @brief max aggregate for public.{{prefix}}_timestamp_ord_ore. +--! @param input public.{{prefix}}_timestamp_ord_ore +--! @return public.{{prefix}}_timestamp_ord_ore +CREATE AGGREGATE {{prefix}}.max(public.{{prefix}}_timestamp_ord_ore) ( + sfunc = {{prefix}}_internal.max_sfunc, + stype = public.{{prefix}}_timestamp_ord_ore, + combinefunc = {{prefix}}_internal.max_sfunc, parallel = safe ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql index 8eb73a1da..6a83371f2 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql @@ -6,562 +6,562 @@ -- REQUIRE: src/v3/sem/ore_block_256/operators.sql --! @file encrypted_domain/timestamp/timestamp_ord_ore_functions.sql ---! @brief Functions for public.eql_v3_timestamp_ord_ore. +--! @brief Functions for public.{{prefix}}_timestamp_ord_ore. ---! @brief Index extractor for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @return eql_v3_internal.ore_block_256 -CREATE FUNCTION eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore) -RETURNS eql_v3_internal.ore_block_256 +--! @brief Index extractor for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @return {{prefix}}_internal.ore_block_256 +CREATE FUNCTION {{prefix}}.ord_term_ore(a public.{{prefix}}_timestamp_ord_ore) +RETURNS {{prefix}}_internal.ore_block_256 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$; +AS $$ SELECT {{prefix}}_internal.ore_block_256(a::jsonb) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.eq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.eq(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) = eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) = {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.eq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.eq(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) = eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) = {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.neq(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.neq(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <> eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <> {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.neq(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.neq(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <> eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) <> {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lt(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) < eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) < {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lt(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) < eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) < {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.lte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.lte(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) <= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) <= {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.lte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.lte(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) <= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) <= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gt(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gt(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) > eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) > {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gt(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gt(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) > eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) > {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore ---! @param b public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. ---! @param a public.eql_v3_timestamp_ord_ore +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. +--! @param a public.{{prefix}}_timestamp_ord_ore --! @param b jsonb --! @return boolean -CREATE FUNCTION eql_v3.gte(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}.gte(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a) >= eql_v3.ord_term_ore(b::public.eql_v3_timestamp_ord_ore) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a) >= {{prefix}}.ord_term_ore(b::public.{{prefix}}_timestamp_ord_ore) $$; ---! @brief Operator wrapper for public.eql_v3_timestamp_ord_ore. +--! @brief Operator wrapper for public.{{prefix}}_timestamp_ord_ore. --! @param a jsonb ---! @param b public.eql_v3_timestamp_ord_ore +--! @param b public.{{prefix}}_timestamp_ord_ore --! @return boolean -CREATE FUNCTION eql_v3.gte(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}.gte(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE -AS $$ SELECT eql_v3.ord_term_ore(a::public.eql_v3_timestamp_ord_ore) >= eql_v3.ord_term_ore(b) $$; +AS $$ SELECT {{prefix}}.ord_term_ore(a::public.{{prefix}}_timestamp_ord_ore) >= {{prefix}}.ord_term_ore(b) $$; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contains(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contains(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal.contained_by(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal.contained_by(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector text) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ore, selector text) +RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a public.eql_v3_timestamp_ord_ore, selector integer) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a public.{{prefix}}_timestamp_ord_ore, selector integer) +RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator ---! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->"(a jsonb, selector public.eql_v3_timestamp_ord_ore) -RETURNS public.eql_v3_timestamp_ord_ore IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_timestamp_ord_ore'; END; $$ +--! @param selector public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator +--! @return public.{{prefix}}_timestamp_ord_ore never returned — the function always raises "operator not supported" +CREATE FUNCTION {{prefix}}_internal."->"(a jsonb, selector public.{{prefix}}_timestamp_ord_ore) +RETURNS public.{{prefix}}_timestamp_ord_ore IMMUTABLE PARALLEL SAFE +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param selector text right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector text) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ore, selector text) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param selector integer right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a public.eql_v3_timestamp_ord_ore, selector integer) +CREATE FUNCTION {{prefix}}_internal."->>"(a public.{{prefix}}_timestamp_ord_ore, selector integer) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param selector public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."->>"(a jsonb, selector public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal."->>"(a jsonb, selector public.{{prefix}}_timestamp_ord_ore) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."?"(a public.{{prefix}}_timestamp_ord_ore, b text) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?|"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?|"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."?&"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."?&"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@?"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@?"(a public.{{prefix}}_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal."@@"(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonpath right operand of the blocked operator --! @return boolean never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."@@"(a public.eql_v3_timestamp_ord_ore, b jsonpath) +CREATE FUNCTION {{prefix}}_internal."@@"(a public.{{prefix}}_timestamp_ord_ore, b jsonpath) RETURNS boolean IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return text never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#>>"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#>>"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS text IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b text) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b integer right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b integer) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b integer) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."-"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b text[] right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."#-"(a public.eql_v3_timestamp_ord_ore, b text[]) +CREATE FUNCTION {{prefix}}_internal."#-"(a public.{{prefix}}_timestamp_ord_ore, b text[]) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ore, b public.{{prefix}}_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! ---! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator +--! @param a public.{{prefix}}_timestamp_ord_ore left operand of the blocked operator --! @param b jsonb right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a public.eql_v3_timestamp_ord_ore, b jsonb) +CREATE FUNCTION {{prefix}}_internal."||"(a public.{{prefix}}_timestamp_ord_ore, b jsonb) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; ---! @brief Unsupported operator blocker for public.eql_v3_timestamp_ord_ore. +--! @brief Unsupported operator blocker for public.{{prefix}}_timestamp_ord_ore. --! ---! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises; +--! Intercepts an operator that is not supported on public.{{prefix}}_timestamp_ord_ore and always raises; --! it never returns a value. The declared signature exists only so the operator --! resolves to this blocker instead of a base-type fallback. --! --! @param a jsonb left operand of the blocked operator ---! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator +--! @param b public.{{prefix}}_timestamp_ord_ore right operand of the blocked operator --! @return jsonb never returned — the function always raises "operator not supported" -CREATE FUNCTION eql_v3_internal."||"(a jsonb, b public.eql_v3_timestamp_ord_ore) +CREATE FUNCTION {{prefix}}_internal."||"(a jsonb, b public.{{prefix}}_timestamp_ord_ore) RETURNS jsonb IMMUTABLE PARALLEL SAFE -AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_timestamp_ord_ore'; END; $$ +AS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.{{prefix}}_timestamp_ord_ore'; END; $$ LANGUAGE plpgsql; diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql index b12b343af..cbf75399f 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_ord_ore_operators.sql @@ -4,257 +4,257 @@ -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql --! @file encrypted_domain/timestamp/timestamp_ord_ore_operators.sql ---! @brief Operators for public.eql_v3_timestamp_ord_ore. +--! @brief Operators for public.{{prefix}}_timestamp_ord_ore. CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.eq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR = ( - FUNCTION = eql_v3.eq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.eq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.neq, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR <> ( - FUNCTION = eql_v3.neq, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.neq, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR < ( - FUNCTION = eql_v3.lt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.lte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR <= ( - FUNCTION = eql_v3.lte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.lte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gt, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR > ( - FUNCTION = eql_v3.gt, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gt, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb, + FUNCTION = {{prefix}}.gte, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR >= ( - FUNCTION = eql_v3.gte, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore, + FUNCTION = {{prefix}}.gte, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore, COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @> ( - FUNCTION = eql_v3_internal.contains, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal.contains, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR <@ ( - FUNCTION = eql_v3_internal.contained_by, - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal.contained_by, + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR -> ( - FUNCTION = eql_v3_internal."->", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."->", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR ->> ( - FUNCTION = eql_v3_internal."->>", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."->>", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR ? ( - FUNCTION = eql_v3_internal."?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."?", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR ?| ( - FUNCTION = eql_v3_internal."?|", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?|", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR ?& ( - FUNCTION = eql_v3_internal."?&", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."?&", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR @? ( - FUNCTION = eql_v3_internal."@?", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@?", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR @@ ( - FUNCTION = eql_v3_internal."@@", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonpath + FUNCTION = {{prefix}}_internal."@@", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonpath ); CREATE OPERATOR #> ( - FUNCTION = eql_v3_internal."#>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #>> ( - FUNCTION = eql_v3_internal."#>>", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#>>", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = integer + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = integer ); CREATE OPERATOR - ( - FUNCTION = eql_v3_internal."-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."-", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR #- ( - FUNCTION = eql_v3_internal."#-", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = text[] + FUNCTION = {{prefix}}_internal."#-", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = text[] ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = public.eql_v3_timestamp_ord_ore, RIGHTARG = jsonb + FUNCTION = {{prefix}}_internal."||", + LEFTARG = public.{{prefix}}_timestamp_ord_ore, RIGHTARG = jsonb ); CREATE OPERATOR || ( - FUNCTION = eql_v3_internal."||", - LEFTARG = jsonb, RIGHTARG = public.eql_v3_timestamp_ord_ore + FUNCTION = {{prefix}}_internal."||", + LEFTARG = jsonb, RIGHTARG = public.{{prefix}}_timestamp_ord_ore ); diff --git a/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql b/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql index e20c626fe..c0d903b1b 100644 --- a/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql +++ b/packages/eql/src/v3/scalars/timestamp/timestamp_types.sql @@ -6,47 +6,47 @@ DO $$ BEGIN - --! @brief Encrypted domain public.eql_v3_timestamp. + --! @brief Encrypted domain public.{{prefix}}_timestamp. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_timestamp' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_timestamp AS jsonb + CREATE DOMAIN public.{{prefix}}_timestamp AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_timestamp IS 'EQL encrypted timestamp (storage only)'; + COMMENT ON DOMAIN public.{{prefix}}_timestamp IS 'EQL encrypted timestamp (storage only)'; - --! @brief Encrypted domain public.eql_v3_timestamp_eq. + --! @brief Encrypted domain public.{{prefix}}_timestamp_eq. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_eq' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_timestamp_eq' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_timestamp_eq AS jsonb + CREATE DOMAIN public.{{prefix}}_timestamp_eq AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'hm' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_timestamp_eq IS 'EQL encrypted timestamp (equality)'; + COMMENT ON DOMAIN public.{{prefix}}_timestamp_eq IS 'EQL encrypted timestamp (equality)'; - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ore. + --! @brief Encrypted domain public.{{prefix}}_timestamp_ord_ore. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_timestamp_ord_ore' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ore AS jsonb + CREATE DOMAIN public.{{prefix}}_timestamp_ord_ore AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' @@ -55,46 +55,46 @@ BEGIN AND VALUE ? 'ob' AND jsonb_typeof(VALUE -> 'ob') = 'array' AND jsonb_array_length(VALUE -> 'ob') > 0 - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord_ore IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_timestamp_ord. + --! @brief Encrypted domain public.{{prefix}}_timestamp_ord. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_timestamp_ord' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord AS jsonb + CREATE DOMAIN public.{{prefix}}_timestamp_ord AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord IS 'EQL encrypted timestamp (equality, ordering)'; - --! @brief Encrypted domain public.eql_v3_timestamp_ord_ope. + --! @brief Encrypted domain public.{{prefix}}_timestamp_ord_ope. IF NOT EXISTS ( SELECT 1 FROM pg_type - WHERE typname = 'eql_v3_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace + WHERE typname = '{{prefix}}_timestamp_ord_ope' AND typnamespace = 'public'::regnamespace ) THEN - CREATE DOMAIN public.eql_v3_timestamp_ord_ope AS jsonb + CREATE DOMAIN public.{{prefix}}_timestamp_ord_ope AS jsonb CHECK ( jsonb_typeof(VALUE) = 'object' AND VALUE ? 'v' AND VALUE ? 'i' AND VALUE ? 'c' AND VALUE ? 'op' - AND VALUE->>'v' = '3' + AND VALUE->>'v' = '{{eql_version}}' ); END IF; - COMMENT ON DOMAIN public.eql_v3_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; + COMMENT ON DOMAIN public.{{prefix}}_timestamp_ord_ope IS 'EQL encrypted timestamp (equality, ordering)'; END $$; From f4c245cdcd870b89a56ca6196ea4e96ba1165d01 Mon Sep 17 00:00:00 2001 From: Dan Draper Date: Mon, 12 Oct 2026 22:45:49 +1100 Subject: [PATCH 3/3] fix(eql): keep the placeholder build's gates able to fail Gate 1 of verify_installer_complete.sh compared the order against the rendered tree, which build.sh writes from that same order, so a dropped file could no longer fail it. It now lists the source tree and maps the paths into the rendered namespace (a truncated order fails again). The Doxygen filter read through a process substitution, whose exit status is lost, so an unreadable input passed docs_v3_grep.sh with empty output; it is a plain pipe under pipefail now. eql-codegen render refuses an absolute or .. path instead of writing over the source. build/ is anchored so tasks/build/ is not ignored, the codegen templates are build cache sources, a moved doc comment is back on its function, and the schema, JSON and pin-script comments name the rendered version (v3 output is byte-identical). --- packages/eql/.gitignore | 4 +- .../eql/crates/eql-codegen/src/bindings.rs | 14 ++--- packages/eql/crates/eql-codegen/src/render.rs | 56 +++++++++++++++++-- packages/eql/src/v3/json/types.sql | 4 +- packages/eql/src/v3/schema.sql | 10 ++-- packages/eql/tasks/build.sh | 2 +- packages/eql/tasks/docs/doxygen-filter.sh | 8 ++- packages/eql/tasks/pin_search_path_v3.sql | 2 +- .../tasks/test/verify_installer_complete.sh | 6 +- 9 files changed, 81 insertions(+), 25 deletions(-) diff --git a/packages/eql/.gitignore b/packages/eql/.gitignore index 46bf60b2e..60e72f5a6 100644 --- a/packages/eql/.gitignore +++ b/packages/eql/.gitignore @@ -262,5 +262,5 @@ docs/handoff/2026-06-10-v3-jsonb-fixture-alignment.md .claude/ # Rendered SQL per EQL version, written by tasks/build.sh from the placeholder -# source (ADR-0002). -build/ +# source (ADR-0002). Anchored: tasks/build/ is tracked. +/build/ diff --git a/packages/eql/crates/eql-codegen/src/bindings.rs b/packages/eql/crates/eql-codegen/src/bindings.rs index 2fe4be39a..ce50f07a1 100644 --- a/packages/eql/crates/eql-codegen/src/bindings.rs +++ b/packages/eql/crates/eql-codegen/src/bindings.rs @@ -83,6 +83,13 @@ fn capability_label(domain_name: &str) -> &'static str { } } +/// The schema-qualified `eql_v3` domain a payload struct binds, e.g. +/// `public.eql_v3_integer_eq`. The bindings describe v3 payloads only, so they +/// name it literally, where the SQL surface writes the `{{prefix}}` placeholder. +fn v3_domain_name(full: &str) -> String { + format!("public.{}{full}", eql_domains::PUBLIC_TYPNAME_PREFIX) +} + /// Render the catalog-derived struct doc lines for a domain: a summary line /// (`` `public.` —