diff --git a/kafka-streams-app/docs/parity-status.md b/kafka-streams-app/docs/parity-status.md new file mode 100644 index 0000000..92eda7f --- /dev/null +++ b/kafka-streams-app/docs/parity-status.md @@ -0,0 +1,46 @@ +# MobilityKafka parity status — MEOS surface audit + +Generated 2026-05-31 by `tools/parity/parity_audit.py`. + +The MobilityKafka MEOS facade (`org.mobilitydb.kafka.meos.MeosOps*`) exposes MEOS C functions to Flink through JMEOS. This audit measures, per type family, the share of the **MEOS public C API** that the facade exposes and that JMEOS binds. + +**Headline.** The facade exposes **2296 of 2296 public MEOS functions (100.0%)**. The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is 2297 functions; JMEOS binds 2296 of them. 0 bindable functions are not exposed (listed in §3). + +Coverage is **static**: a function counts as covered when the facade declares a method of the same name and arity that delegates to a JMEOS export. + +Per-family runtime behaviour is asserted by `src/test/java/org/mobilitydb/kafka/meos/MeosFacadeSmokeTest.java`, which constructs and reads back a value in the core, geo, cbuffer, npoint and pose families through the facade against libmeos. The cbuffer, npoint and pose families require a libmeos built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock library carries the core and geo surfaces only. + +## 1. Reference surface and method + +- **Denominator**: distinct function names declared `extern` in the MEOS public headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, `meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded. + +- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar. + +- **JMEOS jar**: jar/JMEOS.jar exports 2916 static methods. + +## 2. Per-family coverage of the public MEOS surface + +| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage | +|---|---:|---:|---:|---:| +| core temporal / set / span / spanset / tbox (`meos.h`) | 1343 | 1343 | 0 | 100.0% | +| geo (tgeo / tpoint / stbox) (`meos_geo.h`) | 421 | 421 | 0 | 100.0% | +| cbuffer (`meos_cbuffer.h`) | 175 | 175 | 0 | 100.0% | +| npoint (`meos_npoint.h`) | 119 | 119 | 0 | 100.0% | +| pose (`meos_pose.h`) | 101 | 101 | 0 | 100.0% | +| rgeo (`meos_rgeo.h`) | 68 | 68 | 0 | 100.0% | +| h3 / th3index (`meos_h3.h`) | 69 | 69 | 0 | 100.0% | +| **total** | **2296** | **2296** | **0** | **100.0%** | + +## 3. Bindable MEOS functions not exposed by the facade + +0 functions are present in the public MEOS headers and bound by JMEOS but not generated into the facade: + + +## 4. MobilityDB SQL-surface cross-check + +The facade is also matched against the underlying MEOS C symbol of each addressable `CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols bucketed out; 876 out-of-scope, 113 SQL/plpgsql-composed functions with no single C symbol). Functions the SQL layer implements through the internal MEOS headers (`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`. + +- Addressable distinct C symbols: **1336**; bound by JMEOS: **1044**; exposed by the facade: **1044** (100.0% of the JMEOS-bindable SQL surface). + +- The remaining **292** addressable C symbols are not exported by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names differ from the MEOS function names they call. + diff --git a/kafka-streams-app/tools/parity/emit_gap_methods.py b/kafka-streams-app/tools/parity/emit_gap_methods.py new file mode 100644 index 0000000..aaed4eb --- /dev/null +++ b/kafka-streams-app/tools/parity/emit_gap_methods.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS public-surface functions that the +generated MeosOps* facade does not yet expose. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature (captured via `javap`), so the output compiles by +construction. Family and nature (scalar / sequence-constructor / tiling) are +recorded in the Javadoc; the wiring tier is governed by the wirings layer, not +by the presence of the forwarder. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_gap_methods.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h", "meos_h3.h"] +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/kafka/meos") +OUT = os.path.join(FACADE, "MeosOpsParityGaps.java") +# Forwarder facades are themselves derived; the "already covered" baseline is the +# tier-aware generated OO classes only, so the generator reproduces idempotently. +DERIVED = {"MeosOpsParityGaps.java", "MeosOpsSqlSurface.java"} + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') + + +def family(name, fam): + return fam.get(name, "meos.h") + + +def nature(name): + if name.endswith("_make") or "_from_base_" in name or name.endswith("make_coords"): + return "whole-sequence constructor — not a per-event op" + if name.endswith("_tiles"): + return "multidimensional tiling (windowed)" + return "scalar / stateless" + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + fam, pub = {}, set() + for h in PUBLIC_HEADERS: + for n in set(_DECL.findall(open(os.path.join(INC, h)).read())): + pub.add(n); fam.setdefault(n, h) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + if os.path.basename(f) in DERIVED: + continue + facade |= set(_PUBSTATIC.findall(open(f).read())) + # all JMEOS signatures, grouped by name + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + ret, name, args = m.group(1), m.group(2), m.group(3).strip() + sigs.setdefault(name, []).append((ret, args)) + missing = sorted(n for n in (pub & set(sigs)) - facade) + + L = ["package org.mobilitydb.kafka.meos;", "", + "/**", " * Forwarding facade methods for MEOS public-surface functions not emitted", + " * by the tier-aware code generator. Each method delegates to its JMEOS", + " * {@code functions.GeneratedFunctions} export under the shared", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsParityGaps {", "", + " private MeosOpsParityGaps() { /* utility */ }", ""] + count = 0 + for name in missing: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — {family(name, fam)} · {nature(name)}. */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilitykafka.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"missing public-surface functions: {len(missing)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/kafka-streams-app/tools/parity/emit_sql_surface.py b/kafka-streams-app/tools/parity/emit_sql_surface.py new file mode 100644 index 0000000..d45f86d --- /dev/null +++ b/kafka-streams-app/tools/parity/emit_sql_surface.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Emit forwarding facade methods for MEOS functions that the MobilityDB SQL +layer exposes as user functions but whose implementation lives in the internal +headers (`meos_internal*.h`). JMEOS binds them; exposing them here makes the +Flink facade match the SQL user surface as well as the public MEOS API. + +Each method forwards to its `functions.GeneratedFunctions` export using the +exact JMEOS signature, so the output compiles by construction. + +Run from flink-processor/: + javap -classpath jar/JMEOS.jar -p functions.GeneratedFunctions > /tmp/gen_sigs.txt + python3 tools/parity/emit_sql_surface.py /tmp/gen_sigs.txt +""" +import re, os, sys, glob + +HERE = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +INC = os.environ.get("MEOS_INCLUDE", "/home/esteban/src/MobilityDB/meos/include") +MDB_SQL = os.environ.get("MDB_SQL", "/home/esteban/src/MobilityDB/mobilitydb/sql") +FACADE = os.path.join(HERE, "src/main/java/org/mobilitydb/kafka/meos") +OUT = os.path.join(FACADE, "MeosOpsSqlSurface.java") + +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') +_SIG = re.compile(r'public static (\S+) (\w+)\(([^)]*)\);') +_CREATE = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) +_CSYM = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def header_names(*headers): + names = set() + for h in headers: + names |= set(re.findall(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', open(os.path.join(INC, h)).read(), re.M)) + return names + + +def sql_addressable(): + addr = set() + for path in glob.glob(os.path.join(MDB_SQL, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, MDB_SQL).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in _CREATE.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = _CSYM.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + continue + if sym is not None: + addr.add(key) + return addr + + +def main(): + sigfile = sys.argv[1] if len(sys.argv) > 1 else "/tmp/parity/gen_sigs.txt" + sigs = {} + for line in open(sigfile): + m = _SIG.search(line) + if m: + sigs.setdefault(m.group(2), []).append((m.group(1), m.group(3).strip())) + facade = set() + for f in glob.glob(os.path.join(FACADE, "MeosOps*.java")): + facade |= set(_PUBSTATIC.findall(open(f).read())) + pub = header_names("meos.h", "meos_geo.h", "meos_cbuffer.h", "meos_npoint.h", "meos_pose.h", "meos_rgeo.h") + addr = sql_addressable() + # SQL-addressable, bound by JMEOS, not in the public-surface facade, not already exposed + targets = sorted((addr & set(sigs)) - facade - pub) + + L = ["package org.mobilitydb.kafka.meos;", "", + "/**", " * Forwarding facade methods for MEOS functions that the MobilityDB SQL layer", + " * exposes as user functions but whose implementation lives in the internal headers", + " * ({@code meos_internal*.h}). JMEOS binds them; they are exposed here so the facade", + " * matches the SQL user surface as well as the public MEOS API. Each method delegates", + " * to its {@code functions.GeneratedFunctions} export under the", + " * {@link MeosOpsRuntime#MEOS_AVAILABLE} guard.", + " */", + "public final class MeosOpsSqlSurface {", "", + " private MeosOpsSqlSurface() { /* utility */ }", ""] + count = 0 + for name in targets: + for ret, args in sigs[name]: + params = [a.strip() for a in args.split(",")] if args else [] + decl = ", ".join(f"{t} arg{i}" for i, t in enumerate(params)) + call = ", ".join(f"arg{i}" for i in range(len(params))) + ret_kw = "" if ret == "void" else "return " + L += [f" /** MEOS {{@code {name}}} — SQL-surface function (meos_internal). */", + f" public static {ret} {name}({decl}) {{", + f" if (!MeosOpsRuntime.MEOS_AVAILABLE)", + f' throw new UnsupportedOperationException("{name} requires libmeos' + f' — set -Dmobilitykafka.meos.enabled=true");', + f" {ret_kw}functions.GeneratedFunctions.{name}({call});", + " }", ""] + count += 1 + L.append("}") + open(OUT, "w").write("\n".join(L) + "\n") + print(f"SQL-surface (internal-backed) functions to expose: {len(targets)}") + print(f"forwarding methods emitted: {count}") + print(f"wrote {OUT}") + + +if __name__ == "__main__": + main() diff --git a/kafka-streams-app/tools/parity/meos-ref/PIN.txt b/kafka-streams-app/tools/parity/meos-ref/PIN.txt new file mode 100644 index 0000000..00f3234 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/PIN.txt @@ -0,0 +1 @@ +PIN=2c4243a265 diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/cbuffer.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/cbuffer.h new file mode 100644 index 0000000..205e340 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/cbuffer.h @@ -0,0 +1,136 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for temporal buffers. + */ + +#ifndef __CBUFFER_H__ +#define __CBUFFER_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include + +/***************************************************************************** + * Type definitions + *****************************************************************************/ + +/* Structure to represent circular buffers */ + +struct Cbuffer +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + double radius; /**< radius */ + Datum point; /**< First 8 bytes of the point which is passed by + reference. The extra bytes needed are added upon + creation. */ + /* variable-length data follows */ +}; + +/***************************************************************************** + * fmgr macros + *****************************************************************************/ + +#define DatumGetCbufferP(X) ((Cbuffer *) DatumGetPointer(X)) +#define CbufferPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_CBUFFER_P(X) DatumGetCbufferP(PG_GETARG_DATUM(X)) +#define PG_RETURN_CBUFFER_P(X) PG_RETURN_POINTER(X) + +/*****************************************************************************/ + +/* Validity functions */ + +extern bool ensure_valid_cbuffer_cbuffer(const Cbuffer *cb1, + const Cbuffer *cb2); +extern bool ensure_valid_cbuffer_geo(const Cbuffer *cb, + const GSERIALIZED *gs); +extern bool ensure_valid_cbuffer_stbox(const Cbuffer *cb, const STBox *box); +extern bool ensure_valid_cbufferset_cbuffer(const Set *s, const Cbuffer *cb); + +/* Collinear and interpolation functions */ + +extern bool cbuffer_collinear(const Cbuffer *cb1, const Cbuffer *cb2, + const Cbuffer *cbuf3, double ratio); +extern Cbuffer *cbuffersegm_interpolate(const Cbuffer *start, + const Cbuffer *end, long double ratio); +extern long double cbuffersegm_locate(const Cbuffer *start, const Cbuffer *end, + const Cbuffer *value); + +/* Input/output functions */ + +extern Cbuffer *cbuffer_parse(const char **str, bool end); +extern char *cbuffer_wkt_out(Datum value, int maxdd, bool extended); + +/* Accessor functions */ + +extern const GSERIALIZED *cbuffer_point_p(const Cbuffer *cb); + +extern Datum datum_cbuffer_round(Datum buffer, Datum size); + +/* Transformation functions */ + +extern Cbuffer *cbuffer_transf_pj(const Cbuffer *cb, int32_t srid_to, const LWPROJ *pj); + +/* Distance function */ + +extern double cbuffer_distance(const Cbuffer *cb1, const Cbuffer *cb2); +extern Datum datum_cbuffer_distance(Datum cb1, Datum cb2); +extern int cbuffersegm_distance_turnpt(const Cbuffer *start1, + const Cbuffer *end1, const Cbuffer *start2, const Cbuffer *end2, + TimestampTz lower, TimestampTz upper, TimestampTz *t1, TimestampTz *t2); + +/* Spatial relationship functions */ + +extern int cbuffer_contains(const Cbuffer *cb1, const Cbuffer *cb2); +extern int cbuffer_covers(const Cbuffer *cb1, const Cbuffer *cb2); +extern int cbuffer_disjoint(const Cbuffer *cb1, const Cbuffer *cb2); +extern int cbuffer_intersects(const Cbuffer *cb1, const Cbuffer *cb2); +extern int cbuffer_dwithin(const Cbuffer *cb1, const Cbuffer *cb2, double dist); +extern int cbuffer_touches(const Cbuffer *cb1, const Cbuffer *cb2); + +extern int contains_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int covers_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int disjoint_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int intersects_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int dwithin_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2, double dist); +extern int touches_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); + +extern Datum datum_cbuffer_contains(Datum cb1, Datum cb2); +extern Datum datum_cbuffer_covers(Datum cb1, Datum cb2); +extern Datum datum_cbuffer_disjoint(Datum cb1, Datum cb2); +extern Datum datum_cbuffer_intersects(Datum cb1, Datum cb2); +extern Datum datum_cbuffer_dwithin(Datum cb1, Datum cb2, Datum dist); +extern Datum datum_cbuffer_touches(Datum cb1, Datum cb2); + +/*****************************************************************************/ + +#endif /* __CBUFFER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_cbuffer.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_cbuffer.h new file mode 100644 index 0000000..adc2b62 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_cbuffer.h @@ -0,0 +1,156 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_cbuffer_base Functions for static circular buffers + * @ingroup meos_cbuffer + * @brief Functions for static circular buffers + * + * @defgroup meos_cbuffer_set Functions for circular buffer sets + * @ingroup meos_cbuffer + * @brief Functions for circular buffer sets + * + * @defgroup meos_cbuffer_inout Input and output functions + * @ingroup meos_cbuffer + * @brief Input and output functions for temporal circular buffers + * + * @defgroup meos_cbuffer_constructor Constructor functions + * @ingroup meos_cbuffer + * @brief Constructor functions for temporal circular buffers + * + * @defgroup meos_cbuffer_conversion Conversion functions + * @ingroup meos_cbuffer + * @brief Conversion functions for temporal circular buffers + * + * @defgroup meos_cbuffer_accessor Accessor functions + * @ingroup meos_cbuffer + * @brief Accessor functions for temporal circular buffers + * + * @defgroup meos_cbuffer_transf Transformation functions + * @ingroup meos_cbuffer + * @brief Transformation functions for temporal circular buffers + * + * @defgroup meos_cbuffer_restrict Restriction functions + * @ingroup meos_cbuffer + * @brief Restriction functions for temporal circular buffers + * + * @defgroup meos_cbuffer_dist Distance functions + * @ingroup meos_cbuffer + * @brief Distance functions for temporal circular buffers + * + * @defgroup meos_cbuffer_comp Comparison functions + * @ingroup meos_cbuffer + * @brief Comparison functions for temporal circular buffers + * + * @defgroup meos_cbuffer_comp_ever Ever and always comparison functions + * @ingroup meos_cbuffer_comp + * @brief Ever and always comparison functions for temporal circular buffers + * + * @defgroup meos_cbuffer_comp_temp Temporal comparison functions + * @ingroup meos_cbuffer_comp + * @brief Temporal comparison functions for temporal circular buffers + * + * @defgroup meos_cbuffer_rel Spatial relationship functions + * @ingroup meos_cbuffer + * @brief Spatial relationship functions for temporal circular buffers + * + * @defgroup meos_cbuffer_rel_ever Ever/always relationship functions + * @ingroup meos_cbuffer_rel + * @brief Ever/always relationship functions for temporal circular buffers + * + * @defgroup meos_cbuffer_rel_temp Temporal relationship functions + * @ingroup meos_cbuffer_rel + * @brief Temporal relationship functions for temporal circular buffers + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_cbuffer_base_inout Input and output functions + * @ingroup meos_cbuffer_base + * @brief Input and output functions for static circular buffers + * + * @defgroup meos_cbuffer_base_constructor Constructor functions + * @ingroup meos_cbuffer_base + * @brief Constructor functions for static circular buffers + * + * @defgroup meos_cbuffer_base_conversion Conversion functions + * @ingroup meos_cbuffer_base + * @brief Conversion functions for static circular buffers + * + * @defgroup meos_cbuffer_base_accessor Accessor functions + * @ingroup meos_cbuffer_base + * @brief Accessor functions for static circular buffers + * + * @defgroup meos_cbuffer_base_transf Transformation functions + * @ingroup meos_cbuffer_base + * @brief Transformation functions for static circular buffers + * + * @defgroup meos_cbuffer_base_srid Spatial reference system functions + * @ingroup meos_cbuffer_base + * @brief Spatial reference system functions for static circular buffers + * + * @defgroup meos_cbuffer_base_rel Spatial relationship functions + * @ingroup meos_cbuffer_base + * @brief Spatial relationship functions for static circular buffers + * + * @defgroup meos_cbuffer_base_dist Distance functions + * @ingroup meos_cbuffer_base + * @brief Distance functions for static circular buffers + * + * @defgroup meos_cbuffer_base_comp Comparison functions + * @ingroup meos_cbuffer_base + * @brief Comparison functions for static circular buffers + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_cbuffer_set_inout Input and output functions + * @ingroup meos_cbuffer_set + * @brief Input and output functions for circular buffer sets + * + * @defgroup meos_cbuffer_set_constructor Constructor functions + * @ingroup meos_cbuffer_set + * @brief Constructor functions for circular buffer sets + * + * @defgroup meos_cbuffer_set_conversion Conversion functions + * @ingroup meos_cbuffer_set + * @brief Conversion functions for circular buffer sets + * + * @defgroup meos_cbuffer_set_accessor Accessor functions + * @ingroup meos_cbuffer_set + * @brief Accessor functions for circular buffer sets + * + * @defgroup meos_cbuffer_set_setops Set operations + * @ingroup meos_cbuffer_set + * @brief Set operations for circular buffer sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_internal_cbuffer.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_internal_cbuffer.h new file mode 100644 index 0000000..65fdb3d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/doxygen_meos_internal_cbuffer.h @@ -0,0 +1,132 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_internal_cbuffer_base Functions for static circular buffers + * @ingroup meos_internal_cbuffer + * @brief Functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_set Functions for circular buffer sets + * @ingroup meos_internal_cbuffer + * @brief Functions for circular buffer sets + * + * @defgroup meos_internal_cbuffer_inout Input and output functions + * @ingroup meos_internal_cbuffer + * @brief Input and output functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_constructor Constructor functions + * @ingroup meos_internal_cbuffer + * @brief Constructor functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_conversion Conversion functions + * @ingroup meos_internal_cbuffer + * @brief Conversion functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_accessor Accessor functions + * @ingroup meos_internal_cbuffer + * @brief Accessor functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_restrict Restriction functions + * @ingroup meos_internal_cbuffer + * @brief Restriction functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_comp Comparison functions + * @ingroup meos_internal_cbuffer + * @brief Comparison functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_comp_ever Ever and always comparison functions + * @ingroup meos_internal_cbuffer_comp + * @brief Ever and always comparison functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_comp_temp Temporal comparison functions + * @ingroup meos_internal_cbuffer_comp + * @brief Temporal comparison functions for temporal circular buffers + * + * @defgroup meos_internal_cbuffer_dist Distance functions + * @ingroup meos_internal_cbuffer + * @brief Distance functions for temporal circular buffers + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_cbuffer_base_inout Input and output functions + * @ingroup meos_internal_cbuffer_base + * @brief Input and output functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_constructor Constructor functions + * @ingroup meos_internal_cbuffer_base + * @brief Constructor functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_conversion Conversion functions + * @ingroup meos_internal_cbuffer_base + * @brief Conversion functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_accessor Accessor functions + * @ingroup meos_internal_cbuffer_base + * @brief Accessor functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_transf Transformation functions + * @ingroup meos_internal_cbuffer_base + * @brief Transformation functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_srid Spatial reference system functions + * @ingroup meos_internal_cbuffer_base + * @brief Spatial reference system functions for static circular buffers + * + * @defgroup meos_internal_cbuffer_base_comp Comparison functions + * @ingroup meos_internal_cbuffer_base + * @brief Comparison functions for static circular buffers + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_cbuffer_set_inout Input and output functions + * @ingroup meos_internal_cbuffer_set + * @brief Input and output functions for circular buffer sets + * + * @defgroup meos_internal_cbuffer_set_constructor Constructor functions + * @ingroup meos_internal_cbuffer_set + * @brief Constructor functions for circular buffer sets + * + * @defgroup meos_internal_cbuffer_set_conversion Conversion functions + * @ingroup meos_internal_cbuffer_set + * @brief Conversion functions for circular buffer sets + * + * @defgroup meos_internal_cbuffer_set_accessor Accessor functions + * @ingroup meos_internal_cbuffer_set + * @brief Accessor functions for circular buffer sets + * + * @defgroup meos_internal_cbuffer_set_setops Set operations + * @ingroup meos_internal_cbuffer_set + * @brief Set operations for circular buffer sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer.h new file mode 100644 index 0000000..c68e9a0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer.h @@ -0,0 +1,74 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal distance for temporal network points. + */ + +#ifndef __TCBUFFER_H__ +#define __TCBUFFER_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "cbuffer/cbuffer.h" + +/*****************************************************************************/ + +/* Validity functions */ + +extern bool ensure_valid_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb); +extern bool ensure_valid_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_valid_tcbuffer_stbox(const Temporal *temp, + const STBox *box); +extern bool ensure_valid_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2); + +/* Interpolation functions */ + +extern int tcbuffersegm_intersection_value(Datum start, Datum end, + Datum value, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); +extern int tcbuffersegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); + +extern int tcbuffersegm_dwithin_turnpt(Datum start1, Datum end1, Datum start2, + Datum end2, Datum dist, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); +extern int tcbuffersegm_distance_turnpt(Datum start1, Datum end1, Datum start2, + Datum end2, Datum dist UNUSED, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); + +/*****************************************************************************/ + +#endif /* __TCBUFFER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_boxops.h new file mode 100644 index 0000000..72d6010 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_boxops.h @@ -0,0 +1,59 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Bounding box operators for temporal circular buffers. + */ + +#ifndef __TCBUFFER_BOXOPS_H__ +#define __TCBUFFER_BOXOPS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "cbuffer/cbuffer.h" + +/*****************************************************************************/ + +extern bool cbuffer_set_stbox(const Cbuffer *cb, STBox *box); +extern void cbufferarr_set_stbox(const Datum *values, int count, STBox *box); +extern bool cbuffer_timestamptz_set_stbox(const Cbuffer *cb, TimestampTz t, + STBox *box); +extern bool cbuffer_tstzspan_set_stbox(const Cbuffer *cb, const Span *s, + STBox *box); + +extern void tcbufferinst_set_stbox(const TInstant *inst, STBox *box); +extern void tcbufferinstarr_set_stbox(TInstant **instants, int count, + STBox *box); +extern void tcbufferseq_expand_stbox(const TSequence *seq, const TInstant *inst); + +/*****************************************************************************/ + +#endif /* __TCBUFFER_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialfuncs.h new file mode 100644 index 0000000..3f43171 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialfuncs.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal distance for temporal network points. + */ + +#ifndef __TCBUFFER_SPATIALFUNCS_H__ +#define __TCBUFFER_SPATIALFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "cbuffer/cbuffer.h" + +/*****************************************************************************/ + +/* Traversed area functions */ + +extern GSERIALIZED *tcbufferinst_trav_area(const TInstant *inst); +extern GSERIALIZED *tcbufferseq_trav_area(const TSequence *seq); +extern GSERIALIZED *tcbufferseqset_trav_area(const TSequenceSet *ss); +extern GSERIALIZED *tcbuffersegm_trav_area(const TInstant *inst1, + const TInstant *inst2); + +/* Restriction functions */ + +extern Temporal *tcbuffer_restrict_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool atfunc); +extern Temporal *tcbuffer_restrict_stbox(const Temporal *temp, + const STBox *box, bool border_inc, bool atfunc); +extern Temporal *tcbuffer_restrict_geom(const Temporal *temp, + const GSERIALIZED *gs, bool atfunc); + +/*****************************************************************************/ + +#endif /* __TCBUFFER_SPATIALFUNCS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialrels.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialrels.h new file mode 100644 index 0000000..d4dfc6d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_spatialrels.h @@ -0,0 +1,107 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatial relationships for temporal points. + */ + +#ifndef __TCBUFFER_SPATIALRELS_H__ +#define __TCBUFFER_SPATIALRELS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "cbuffer/cbuffer.h" + +/*****************************************************************************/ + +extern int ea_contains_geo_tcbuffer(const GSERIALIZED *gs, + const Temporal *temp, bool ever); +extern int ea_contains_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool ever); +extern int ea_contains_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool ever); +extern int ea_contains_cbuffer_tcbuffer(const Cbuffer *cb, + const Temporal *temp, bool ever); +// extern int ea_contains_tcbuffer_tcbuffer(const Temporal *temp1, +// const Temporal *temp2, bool ever); + +extern int ea_covers_geo_tcbuffer(const GSERIALIZED *gs, + const Temporal *temp, bool ever); +extern int ea_covers_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool ever); +extern int ea_covers_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool ever); +extern int ea_covers_cbuffer_tcbuffer(const Cbuffer *cb, + const Temporal *temp, bool ever); +extern int ea_covers_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, bool ever); + +extern int ea_disjoint_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool ever); +extern int ea_disjoint_geo_tcbuffer(const GSERIALIZED *gs, + const Temporal *temp, bool ever); +extern int ea_disjoint_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool ever); +extern int ea_disjoint_cbuffer_tcbuffer(const Cbuffer *cb, + const Temporal *temp, bool ever); +extern int ea_disjoint_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, bool ever); + +extern int ea_intersects_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool ever); +extern int ea_intersects_geo_tcbuffer(const GSERIALIZED *gs, + const Temporal *temp, bool ever); +extern int ea_intersects_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool ever); +extern int ea_intersects_cbuffer_tcbuffer(const Cbuffer *cb, + const Temporal *temp, bool ever); +extern int ea_intersects_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, bool ever); + +extern int ea_touches_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool ever); +extern int ea_touches_geo_tcbuffer(const GSERIALIZED *gs, + const Temporal *temp, bool ever); +extern int ea_touches_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool ever); +extern int ea_touches_cbuffer_tcbuffer(const Cbuffer *cb, + const Temporal *temp, bool ever); +extern int ea_touches_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, bool ever); + +extern int edwithin_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, double dist); +extern int adwithin_tcbuffer_tcbuffer(const Temporal *temp1, + const Temporal *temp2, double dist); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_tempspatialrels.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_tempspatialrels.h new file mode 100644 index 0000000..7c6d0be --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/cbuffer/tcbuffer_tempspatialrels.h @@ -0,0 +1,54 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatiotemporal relationships for temporal points. + */ + +#ifndef __TCBUFFER_TEMPSPATIALRELS_H__ +#define __TCBUFFER_TEMPSPATIALRELS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "cbuffer/cbuffer.h" + +/*****************************************************************************/ + +extern Temporal *tinterrel_tcbuffer_cbuffer(const Temporal *temp, + const Cbuffer *cb, bool tinter); +extern Temporal *tinterrel_tcbuffer_geo(const Temporal *temp, + const GSERIALIZED *gs, bool tinter); +// extern Temporal *tinterrel_tcbuffer_tcbuffer(const Temporal *temp1, +// const Temporal *temp2, bool tinter); + +/*****************************************************************************/ + +#endif /* __TCBUFFER_TEMPSPATIALRELS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_geo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_geo.h new file mode 100644 index 0000000..8f590fb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_geo.h @@ -0,0 +1,252 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_geo_base Functions for static geometries + * @ingroup meos_geo + * @brief Functions for static geometries + * + * @defgroup meos_geo_set Functions for spatial sets + * @ingroup meos_geo + * @brief Functions for spatial sets + * + * @defgroup meos_geo_box Functions for spatiotemporal boxes + * @ingroup meos_geo + * @brief Functions for spatiotemporal boxes + * + * @defgroup meos_geo_inout Input and output functions + * @ingroup meos_geo + * @brief Input and output functions for temporal geometries + * + * @defgroup meos_geo_constructor Constructor functions + * @ingroup meos_geo + * @brief Constructor functions for temporal geometries + * + * @defgroup meos_geo_conversion Conversion functions + * @ingroup meos_geo + * @brief Conversion functions for temporal geometries + * + * @defgroup meos_geo_accessor Accessor functions + * @ingroup meos_geo + * @brief Accessor functions for temporal geometries + * + * @defgroup meos_geo_transf Transformation functions + * @ingroup meos_geo + * @brief Transformation functions for temporal geometries + * + * @defgroup meos_geo_restrict Restriction functions + * @ingroup meos_geo + * @brief Restriction functions for temporal geometries + * + * @defgroup meos_geo_comp Comparison functions + * @ingroup meos_geo + * @brief Comparison functions for temporal geometries + * + * @defgroup meos_geo_comp_ever Ever and always comparison functions + * @ingroup meos_geo_comp + * @brief Ever and always comparison functions for temporal geometries + * + * @defgroup meos_geo_comp_temp Temporal comparison functions + * @ingroup meos_geo_comp + * @brief Temporal comparison functions for temporal geometries + * + * @defgroup meos_geo_bbox Bounding box functions + * @ingroup meos_geo + * @brief Bounding box functions for temporal geometries + * + * @defgroup meos_geo_bbox_split Split functions + * @ingroup meos_geo_bbox + * @brief Split functions for temporal geometries + * + * @defgroup meos_geo_bbox_topo Topological functions + * @ingroup meos_geo_bbox + * @brief Topological functions for temporal geometries + * + * @defgroup meos_geo_bbox_pos Position functions + * @ingroup meos_geo_bbox + * @brief Position functions for temporal geometries + * + * @defgroup meos_geo_distance Distance functions + * @ingroup meos_geo + * @brief Distance functions for temporal geometries + * + * @defgroup meos_geo_srid Spatial reference system functions + * @ingroup meos_geo + * @brief Spatial reference system functions for temporal geometries + * + * @defgroup meos_geo_rel Spatial relationship functions + * @ingroup meos_geo + * @brief Spatial relationship functions for temporal geometries + * + * @defgroup meos_geo_rel_ever Ever/always relationship functions + * @ingroup meos_geo_rel + * @brief Ever/always relationship functions for temporal geometries + * + * @defgroup meos_geo_rel_temp Temporal relationship functions + * @ingroup meos_geo_rel + * @brief Temporal relationship functions for temporal geometries + * + * @defgroup meos_geo_agg Aggregate functions + * @ingroup meos_geo + * @brief Aggregate functions for temporal geometries + * + * @defgroup meos_geo_tile Tile functions + * @ingroup meos_geo + * @brief Tile functions for temporal geometries + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_geo_base_inout Input and output functions + * @ingroup meos_geo_base + * @brief Input and output functions for static geometries + * + * @defgroup meos_geo_base_constructor Constructor functions + * @ingroup meos_geo_base + * @brief Constructor functions for static geometries + * + * @defgroup meos_geo_base_conversion Conversion functions + * @ingroup meos_geo_base + * @brief Conversion functions for static geometries + * + * @defgroup meos_geo_base_accessor Accessor functions + * @ingroup meos_geo_base + * @brief Accessor functions for static geometries + * + * @defgroup meos_geo_base_transf Transformation functions + * @ingroup meos_geo_base + * @brief Transformation functions for static geometries + * + * @defgroup meos_geo_base_srid Spatial reference system functions + * @ingroup meos_geo_base + * @brief Spatial reference system functions for temporal geos + * + * @defgroup meos_geo_base_spatial Spatial processing functions + * @ingroup meos_geo_base + * @brief Spatial processing functions for static geometries + * + * @defgroup meos_geo_base_rel Spatial relationship functions + * @ingroup meos_geo_base + * @brief Spatial relationship functions for temporal geos + * + * @defgroup meos_geo_base_bbox Bounding box functions + * @ingroup meos_geo_base + * @brief Bounding box functions for static geometries + * + * @defgroup meos_geo_base_distance Distance functions + * @ingroup meos_geo_base + * @brief Distance functions for static geometries + * + * @defgroup meos_geo_base_comp Comparison functions + * @ingroup meos_geo_base + * @brief Comparison functions for static geometries + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_geo_set_inout Input and output functions + * @ingroup meos_geo_set + * @brief Input and output functions for spatial sets + * + * @defgroup meos_geo_set_constructor Constructor functions + * @ingroup meos_geo_set + * @brief Constructor functions for spatial sets + * + * @defgroup meos_geo_set_conversion Conversion functions + * @ingroup meos_geo_set + * @brief Conversion functions for spatial sets + * + * @defgroup meos_geo_set_accessor Accessor functions + * @ingroup meos_geo_set + * @brief Accessor functions for spatial sets + * + * @defgroup meos_geo_set_srid Spatial reference system functions + * @ingroup meos_geo_set + * @brief Spatial reference system functions for spatial sets + * + * @defgroup meos_geo_set_setops Set operations + * @ingroup meos_geo_set + * @brief Set operations for geometry sets + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_geo_box_inout Input and output functions + * @ingroup meos_geo_box + * @brief Input and output functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_constructor Constructor functions + * @ingroup meos_geo_box + * @brief Constructor functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_conversion Conversion functions + * @ingroup meos_geo_box + * @brief Conversion functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_accessor Accessor functions + * @ingroup meos_geo_box + * @brief Accessor functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_transf Transformation functions + * @ingroup meos_geo_box + * @brief Transformation functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_srid Spatial reference system functions + * @ingroup meos_geo_box + * @brief Spatial reference system functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_bbox Bounding box functions + * @ingroup meos_geo_box + * @brief Bounding box functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_topo Topological functions + * @ingroup meos_geo_box_bbox + * @brief Topological functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_pos Position functions + * @ingroup meos_geo_box_bbox + * @brief Position functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_set Set functions + * @ingroup meos_geo_box + * @brief Set functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_comp Comparison functions + * @ingroup meos_geo_box + * @brief Comparison functions for spatiotemporal boxes + * + * @defgroup meos_geo_box_index Index functions + * @ingroup meos_geo_box + * @brief In-memory RTree index for spatiotemporal boxes + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_internal_geo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_internal_geo.h new file mode 100644 index 0000000..1773884 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/doxygen_meos_internal_geo.h @@ -0,0 +1,236 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_internal_geo_base Functions for static geometries + * @ingroup meos_internal_geo + * @brief Functions for static geometries + * + * @defgroup meos_internal_geo_set Functions for geometry sets + * @ingroup meos_internal_geo + * @brief Functions for geometry sets + * + * @defgroup meos_internal_geo_box Functions for spatiotemporal boxes + * @ingroup meos_internal_geo + * @brief Functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_inout Input and output functions + * @ingroup meos_internal_geo + * @brief Input and output functions for temporal geometries + * + * @defgroup meos_internal_geo_constructor Constructor functions + * @ingroup meos_internal_geo + * @brief Constructor functions for temporal geometries + * + * @defgroup meos_internal_geo_conversion Conversion functions + * @ingroup meos_internal_geo + * @brief Conversion functions for temporal geometries + * + * @defgroup meos_internal_geo_accessor Accessor functions + * @ingroup meos_internal_geo + * @brief Accessor functions for temporal geometries + * + * @defgroup meos_internal_geo_transf Transformation functions + * @ingroup meos_internal_geo + * @brief Transformation functions for temporal geometries + * + * @defgroup meos_internal_geo_restrict Restriction functions + * @ingroup meos_internal_geo + * @brief Restriction functions for temporal geometries + * + * @defgroup meos_internal_geo_comp Comparison functions + * @ingroup meos_internal_geo + * @brief Comparison functions for temporal geometries + * + * @defgroup meos_internal_geo_comp_ever Ever and always comparison functions + * @ingroup meos_internal_geo_comp + * @brief Ever and always comparison functions for temporal geometries + * + * @defgroup meos_internal_geo_comp_temp Temporal comparison functions + * @ingroup meos_internal_geo_comp + * @brief Temporal comparison functions for temporal geometries + * + * @defgroup meos_internal_geo_bbox Bounding box functions + * @ingroup meos_internal_geo + * @brief Bounding box functions for temporal geometries + * + * @defgroup meos_internal_geo_bbox_topo Topological functions + * @ingroup meos_internal_geo_bbox + * @brief Topological functions for temporal geometries + * + * @defgroup meos_internal_geo_bbox_pos Position functions + * @ingroup meos_internal_geo_bbox + * @brief Position functions for temporal geometries + * + * @defgroup meos_internal_geo_dist Distance functions + * @ingroup meos_internal_geo + * @brief Distance functions for temporal geometries + * + * @defgroup meos_internal_geo_srid Spatial reference system functions + * @ingroup meos_internal_geo + * @brief Spatial reference system functions for temporal geos + * + * @defgroup meos_internal_geo_rel Spatial relationship functions + * @ingroup meos_internal_geo + * @brief Spatial relationship functions for temporal geos + * + * @defgroup meos_internal_geo_rel_ever Ever/always relationship functions + * @ingroup meos_internal_geo_rel + * @brief Ever/always relationship functions for temporal geometries + * + * @defgroup meos_internal_geo_rel_temp Temporal relationship functions + * @ingroup meos_internal_geo_rel + * @brief Temporal relationship functions for temporal geometries + * + * @defgroup meos_internal_geo_agg Aggregate functions + * @ingroup meos_internal_geo + * @brief Aggregate functions for temporal geometries + * + * @defgroup meos_internal_geo_tile Tile functions + * @ingroup meos_internal_geo + * @brief Tile functions for temporal geometries + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_geo_base_inout Input and output functions + * @ingroup meos_internal_geo_base + * @brief Input and output functions for static geometries + * + * @defgroup meos_internal_geo_base_constructor Constructor functions + * @ingroup meos_internal_geo_base + * @brief Constructor functions for static geometries + * + * @defgroup meos_internal_geo_base_conversion Conversion functions + * @ingroup meos_internal_geo_base + * @brief Conversion functions for static geometries + * + * @defgroup meos_internal_geo_base_accessor Accessor functions + * @ingroup meos_internal_geo_base + * @brief Accessor functions for static geometries + * + * @defgroup meos_internal_geo_base_transf Transformation functions + * @ingroup meos_internal_geo_base + * @brief Transformation functions for static geometries + * + * @defgroup meos_internal_geo_base_srid Spatial reference system functions + * @ingroup meos_internal_geo_base + * @brief Spatial reference system functions for temporal geos + * + * @defgroup meos_internal_geo_base_spatial Spatial processing functions + * @ingroup meos_internal_geo_base + * @brief Spatial processing functions for static geometries + * + * @defgroup meos_internal_geo_base_rel Spatial relationship functions + * @ingroup meos_internal_geo_base + * @brief Spatial relationship functions for temporal geos + * + * @defgroup meos_internal_geo_base_bbox Bounding box functions + * @ingroup meos_internal_geo_base + * @brief Bounding box functions for static geometries + * + * @defgroup meos_internal_geo_base_comp Comparison functions + * @ingroup meos_internal_geo_base + * @brief Comparison functions for static geometries + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_geo_set_inout Input and output functions + * @ingroup meos_internal_geo_set + * @brief Input and output functions for geometry sets + * + * @defgroup meos_internal_geo_set_constructor Constructor functions + * @ingroup meos_internal_geo_set + * @brief Constructor functions for geometry sets + * + * @defgroup meos_internal_geo_set_conversion Conversion functions + * @ingroup meos_internal_geo_set + * @brief Conversion functions for geometry sets + * + * @defgroup meos_internal_geo_set_accessor Accessor functions + * @ingroup meos_internal_geo_set + * @brief Accessor functions for geometry sets + * + * @defgroup meos_internal_geo_set_setops Set operations + * @ingroup meos_internal_geo_set + * @brief Set operations for geometry sets + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_geo_box_inout Input and output functions + * @ingroup meos_internal_geo_box + * @brief Input and output functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_constructor Constructor functions + * @ingroup meos_internal_geo_box + * @brief Constructor functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_conversion Conversion functions + * @ingroup meos_internal_geo_box + * @brief Conversion functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_accessor Accessor functions + * @ingroup meos_internal_geo_box + * @brief Accessor functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_transf Transformation functions + * @ingroup meos_internal_geo_box + * @brief Transformation functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_srid Spatial reference system functions + * @ingroup meos_internal_geo_box + * @brief Spatial reference system functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_bbox Bounding box functions + * @ingroup meos_internal_geo_box + * @brief Bounding box functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_topo Topological functions + * @ingroup meos_internal_geo_box_bbox + * @brief Topological functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_pos Position functions + * @ingroup meos_internal_geo_box_bbox + * @brief Position functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_set Set functions + * @ingroup meos_internal_geo_box + * @brief Set functions for spatiotemporal boxes + * + * @defgroup meos_internal_geo_box_comp Comparison functions + * @ingroup meos_internal_geo_box + * @brief Comparison functions for spatiotemporal boxes + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/meos_transform.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/meos_transform.h new file mode 100644 index 0000000..c7c4e1c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/meos_transform.h @@ -0,0 +1,66 @@ +/********************************************************************** + * + * PostGIS - Spatial Types for PostgreSQL + * http://postgis.net + * Copyright 2001-2003 Refractions Research Inc. + * + * This is free software; you can redistribute and/or modify it under + * the terms of the GNU General Public Licence. See the COPYING file. + * + **********************************************************************/ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include + +/* Prototypes */ + +extern int lwproj_lookup(int32_t srid_from, int32_t srid_to, LWPROJ **pj); +extern int spheroid_init_from_srid(int32_t srid, SPHEROID *s); +extern void srid_check_latlong(int32_t srid); +extern int srid_is_latlong(int32_t srid); + +/** + * Builtin SRID values + * @{ + */ + +/** Start of the reserved offset */ +#define SRID_RESERVE_OFFSET 999000 + +/** World Mercator, equivalent to EPSG:3395 */ +#define SRID_WORLD_MERCATOR 999000 + +/** Start of UTM North zone, equivalent to EPSG:32601 */ +#define SRID_NORTH_UTM_START 999001 + +/** End of UTM North zone, equivalent to EPSG:32660 */ +#define SRID_NORTH_UTM_END 999060 + +/** Lambert Azimuthal Equal Area (LAEA) North Pole, equivalent to EPSG:3574 */ +#define SRID_NORTH_LAMBERT 999061 + +/** PolarSteregraphic North, equivalent to EPSG:3995 */ +#define SRID_NORTH_STEREO 999062 + +/** Start of UTM South zone, equivalent to EPSG:32701 */ +#define SRID_SOUTH_UTM_START 999101 + +/** Start of UTM South zone, equivalent to EPSG:32760 */ +#define SRID_SOUTH_UTM_END 999160 + +/** Lambert Azimuthal Equal Area (LAEA) South Pole, equivalent to EPSG:3409 */ +#define SRID_SOUTH_LAMBERT 999161 + +/** PolarSteregraphic South, equivalent to EPSG:3031 */ +#define SRID_SOUTH_STEREO 999162 + +/** LAEA zones start (6 latitude bands x up to 20 longitude bands) */ +#define SRID_LAEA_START 999163 + +/** LAEA zones end (6 latitude bands x up to 20 longitude bands) */ +#define SRID_LAEA_END 999283 + +/** @} */ + diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/postgis_funcs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/postgis_funcs.h new file mode 100644 index 0000000..b25d772 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/postgis_funcs.h @@ -0,0 +1,85 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for geometry types corresponding to external + * PostGIS functions in order to bypass the function manager @p fmgr.c. + */ + +#ifndef __POSTGIS_FUNCS_H__ +#define __POSTGIS_FUNCS_H__ + +/*****************************************************************************/ + +/* GEOS */ +#include +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include + +/* Functions borrowed from lwgeom_pg.c */ + +extern GSERIALIZED* geom_serialize(LWGEOM *lwgeom); +extern GSERIALIZED* geog_serialize(LWGEOM *lwgeom); + +/* Functions adapted from gserialized_typmod.c */ + +extern GSERIALIZED *postgis_valid_typmod(GSERIALIZED *gs, int32_t typmod); + +extern char *geo_as_wkt(const GSERIALIZED *gs, int precision, bool extended); + +/* Functions adapted from lwgeom_box.c */ + +extern LWGEOM *box2d_to_lwgeom(GBOX *box, int32_t srid); + +/* Functions adapted from lwgeom_box3d.c */ + +extern LWGEOM *box3d_to_lwgeom(BOX3D *box); + +/* Functions adapted from lwgeom_geos.c */ + +extern GEOSGeometry *POSTGIS2GEOS(const GSERIALIZED *pglwgeom); +extern GSERIALIZED *GEOS2POSTGIS(GEOSGeom geom, char want3d); + +extern bool geom_spatialrel(const GSERIALIZED *gs1, const GSERIALIZED *gs2, + spatialRel rel); + +/* Functions adapted from lwgeom_lrs.c */ + +extern LWGEOM *lwgeom_line_interpolate_point(LWGEOM *geom, double fraction, + int32_t srid, char repeat); + +/*****************************************************************************/ + +#endif /* __POSTGIS_FUNCS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox.h new file mode 100644 index 0000000..67df1b1 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for spatiotemporal bounding boxes. + */ + +#ifndef __STBOX_H__ +#define __STBOX_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include + +/***************************************************************************** + * fmgr macros + *****************************************************************************/ + +#define DatumGetSTboxP(X) ((STBox *) DatumGetPointer(X)) +#define STboxPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_STBOX_P(n) DatumGetSTboxP(PG_GETARG_DATUM(n)) +#define PG_RETURN_STBOX_P(x) return STboxPGetDatum(x) + +/*****************************************************************************/ + +/* Set an STBox from a */ + +extern void point_get_coords(const GSERIALIZED *point, bool hasz, + double *x, double *y, double *z); +extern void tstzset_stbox_slice(Datum tsdatum, STBox *box); +extern void tstzspanset_stbox_slice(Datum psdatum, STBox *box); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox_index.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox_index.h new file mode 100644 index 0000000..6c51c8b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/stbox_index.h @@ -0,0 +1,54 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic routines for indexing temporal numbers + */ + +#ifndef __STBOX_INDEX_H__ +#define __STBOX_INDEX_H__ + +/* PostgreSQL */ +#include +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern bool stbox_index_leaf_consistent(const STBox *key, const STBox *query, + StrategyNumber strategy); +extern bool stbox_gist_inner_consistent(const STBox *key, const STBox *query, + StrategyNumber strategy); +extern bool stbox_index_recheck(StrategyNumber strategy); + +/*****************************************************************************/ + +#endif /* __STBOX_INDEX_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo.h new file mode 100644 index 0000000..12a3ff3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo.h @@ -0,0 +1,65 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for temporal geos. + */ + +#ifndef __TGEO_H__ +#define __TGEO_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/* General functions */ + +extern void mobilitydb_init(void); + +/* Conversion functions */ + +extern STBox *geo_stbox(const GSERIALIZED *gs); +extern GSERIALIZED *stbox_geo(const STBox *box); + +/* Temporal comparisons */ + +extern Temporal *tcomp_geo_tgeo(const GSERIALIZED *gs, + const Temporal *temp, Datum (*func)(Datum, Datum, MeosType)); +extern Temporal *tcomp_tgeo_geo(const Temporal *temp, + const GSERIALIZED *gs, Datum (*func)(Datum, Datum, MeosType)); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_aggfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_aggfuncs.h new file mode 100644 index 0000000..be689c0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_aggfuncs.h @@ -0,0 +1,71 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Aggregate functions for temporal geos. + */ + +#ifndef __TGEO_AGGFUNCS_H__ +#define __TGEO_AGGFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include + + +/*****************************************************************************/ + +/** + * Structure storing the SRID and the dimensionality of the temporal geo + * values for aggregation. Notice that for the moment we do not aggregate + * temporal geographic points. + */ +struct GeoAggregateState +{ + int32_t srid; + bool hasz; +}; + +/*****************************************************************************/ + +extern bool ensure_geoaggstate(const SkipList *state, int32_t srid, bool hasz); +extern bool ensure_geoaggstate_state(const SkipList *state1, + const SkipList *state2); + +extern Temporal **tpoint_transform_tcentroid(const Temporal *temp, int *count); +extern TSequence *tpointinst_tcentroid_finalfn(TInstant **instants, int count, + int32_t srid); +extern TSequenceSet *tpointseq_tcentroid_finalfn(TSequence **sequences, + int count, int32_t srid); +extern Temporal *tpoint_tcentroid_finalfn(SkipList *state); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_distance.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_distance.h new file mode 100644 index 0000000..d7c9bdd --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_distance.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Distance functions for temporal points. + */ + +#ifndef __TGEO_DISTANCE_H__ +#define __TGEO_DISTANCE_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern bool point3d_min_dist(const POINT3DZ *p1, const POINT3DZ *p2, + const POINT3DZ *p3, const POINT3DZ *p4, double *fraction); + +extern int tgeompointsegm_distance_turnpt(Datum start1, Datum end1, + Datum start2, Datum end2, Datum param UNUSED, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); +extern int tgeogpointsegm_distance_turnpt(Datum start1, Datum end1, + Datum start2, Datum end2, Datum param UNUSED, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); + +extern double tnumberinst_distance(const TInstant *inst1, + const TInstant *inst2); +extern double tinstant_distance(const TInstant *inst1, const TInstant *inst2, + datum_func2 func); + +/*****************************************************************************/ + +#endif /* __TGEO_DISTANCE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_restrict.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_restrict.h new file mode 100644 index 0000000..7b792a2 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_restrict.h @@ -0,0 +1,55 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Restriction functions for temporal points. + */ + +#ifndef __TPOINT_RESTRICT_H__ +#define __TPOINT_RESTRICT_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include + +/*****************************************************************************/ + +/* Restriction functions */ + +extern TSequence **tpointseq_at_geom(const TSequence *seq, + const GSERIALIZED *gs, int *count); +extern Span *tpointseq_interperiods(const TSequence *seq, + const GSERIALIZED *gs, int *count); + +/*****************************************************************************/ + +#endif /* __TPOINT_RESTRICT_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialfuncs.h new file mode 100644 index 0000000..b0de08d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialfuncs.h @@ -0,0 +1,208 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatial functions for temporal points. + */ + +#ifndef __TGEO_SPATIALFUNCS_H__ +#define __TGEO_SPATIALFUNCS_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/** Symbolic constants for transforming tgeompoint <-> tgeogpoint */ +#define TGEOMP_TO_TGEOGP true +#define TGEOGP_TO_TGEOMP false + +/** Symbolic constants for transforming tgeompoint <-> tgeogpoint */ +#define TGEOM_TO_TGEOG true +#define TGEOG_TO_TGEOM false + +/** Symbolic constants for transforming tgeo <-> tpoint */ +#define TGEO_TO_TPOINT true +#define TPOINT_TO_TGEO false + +/*****************************************************************************/ + +/* Utility functions */ + +extern void datum_point4d(Datum value, POINT4D *p); +extern int geopoint_cmp(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geopoint_eq(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geopoint_same(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool datum_point_eq(Datum point1, Datum point2); +extern bool datum_point_same(Datum point1, Datum point2); +extern Datum datum2_point_eq(Datum point1, Datum point2); +extern Datum datum2_point_ne(Datum point1, Datum point2); +extern Datum datum2_point_same(Datum point1, Datum point2); +extern Datum datum2_point_nsame(Datum point1, Datum point2); +extern Datum datum2_geom_centroid(Datum geo); +extern Datum datum2_geog_centroid(Datum geo); +extern GSERIALIZED **geo_extract_elements(const GSERIALIZED *gs, int *count); +extern GSERIALIZED *geo_serialize(const LWGEOM *geom); + +/* Generic functions */ + +extern datum_func2 geo_distance_fn(int16 flags); +extern datum_func2 pt_distance_fn(int16 flags); +extern Datum datum_geom_distance2d(Datum geom1, Datum geom2); +extern Datum datum_geom_distance3d(Datum geom1, Datum geom2); +extern Datum datum_geog_distance(Datum geog1, Datum geog2); +extern Datum datum_pt_distance2d(Datum geom1, Datum geom2); +extern Datum datum_pt_distance3d(Datum geom1, Datum geom2); +extern int16 spatial_flags(Datum d, MeosType basetype); + +/* Validity functions */ + +extern bool ensure_srid_is_latlong(int32_t srid); +extern bool ensure_spatial_validity(const Temporal *temp1, + const Temporal *temp2); +extern int spheroid_init_from_srid(int32_t srid, SPHEROID *s); +extern bool ensure_not_geodetic(int16 flags); +extern bool ensure_same_geodetic(int16 flags1, int16 flags2); +extern bool ensure_same_geodetic_geo(const GSERIALIZED *gs1, + const GSERIALIZED *gs2); +extern bool ensure_same_geodetic_tspatial_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_same_geodetic_tspatial_base(const Temporal *temp, + Datum base); +extern bool ensure_srid_known(int32_t srid); +extern bool ensure_same_srid(int32_t srid1, int32_t srid2); +extern bool ensure_same_dimensionality(int16 flags1, int16 flags2); +extern bool same_spatial_dimensionality(int16 flags1, int16 flags2); +extern bool ensure_same_spatial_dimensionality(int16 flags1, int16 flags2); +extern bool ensure_same_dimensionality_geo(const GSERIALIZED *gs1, + const GSERIALIZED *gs2); +extern bool same_dimensionality_tspatial_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_same_dimensionality_tspatial_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_same_spatial_dimensionality_stbox_geo(const STBox *box, + const GSERIALIZED *gs); +extern bool ensure_same_geodetic_stbox_geo(const STBox *box, + const GSERIALIZED *gs); +extern bool ensure_has_Z_geo(const GSERIALIZED *gs); +extern bool ensure_has_not_Z_geo(const GSERIALIZED *gs); +extern bool ensure_has_M_geo(const GSERIALIZED *gs); +extern bool ensure_has_not_M_geo(const GSERIALIZED *gs); +extern bool ensure_not_geodetic_geo(const GSERIALIZED *gs); +extern bool ensure_point_type(const GSERIALIZED *gs); +extern bool ensure_mline_type(const GSERIALIZED *gs); +extern bool circle_type(const GSERIALIZED *gs); +extern bool ensure_circle_type(const GSERIALIZED *gs); +extern bool ensure_not_empty(const GSERIALIZED *gs); +extern bool ensure_valid_stbox_geo(const STBox *box, const GSERIALIZED *gs); +extern bool ensure_valid_tspatial_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_valid_tspatial_base(const Temporal *temp, Datum base); +extern bool ensure_valid_tspatial_tspatial(const Temporal *temp1, + const Temporal *temp2); +extern bool ensure_valid_spatial_stbox_stbox(const STBox *box1, + const STBox *box2); +extern bool ensure_valid_tgeo_stbox(const Temporal *temp, const STBox *box); +extern bool ensure_valid_geo_geo(const GSERIALIZED *gs1, + const GSERIALIZED *gs2); +extern bool ensure_valid_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern bool ensure_valid_tgeo_tgeo(const Temporal *temp1, + const Temporal *temp2); +extern bool ensure_valid_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern bool ensure_valid_tpoint_tpoint(const Temporal *temp1, + const Temporal *temp2); + +extern bool mline_type(const GSERIALIZED *gs); + +/* Functions for extracting coordinates */ + +extern Temporal *tpoint_get_coord(const Temporal *temp, int coord); + +/* Ever/always comparisons */ + +extern int eacomp_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + Datum (*func)(Datum, Datum, MeosType), bool ever); + +/* Functions derived from PostGIS to increase floating-point precision */ + +extern long double closest_point2d_on_segment_ratio(const POINT2D *p, + const POINT2D *A, const POINT2D *B, POINT2D *closest); +extern long double closest_point3dz_on_segment_ratio(const POINT3DZ *p, + const POINT3DZ *A, const POINT3DZ *B, POINT3DZ *closest); +extern long double closest_point_on_segment_sphere(const POINT4D *p, + const POINT4D *A, const POINT4D *B, POINT4D *closest, double *dist); +extern void interpolate_point4d_spheroid(const POINT4D *p1, const POINT4D *p2, + POINT4D *p, const SPHEROID *s, double f); + +/* Functions specializing the PostGIS functions ST_LineInterpolatePoint and + * ST_LineLocatePoint */ + +extern GSERIALIZED *geopoint_make(double x, double y, double z, bool hasz, + bool geodetic, int32_t srid); +extern LWGEOM *lwcircle_make(double x, double y, double radius, int32_t srid); +extern GSERIALIZED *geocircle_make(double x, double y, double radius, + int32_t srid); +extern Datum pointsegm_interpolate(Datum start, Datum end, + long double ratio); +extern long double pointsegm_locate(Datum start, Datum end, Datum point, + double *dist); + +/* Intersection functions */ + +extern int tgeompointsegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); +extern int tgeogpointsegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); + +extern bool geopoint_collinear(Datum value1, Datum value2, Datum value3, + double ratio, bool hasz, bool geodetic); + +/* Trajectory functions */ + +extern LWGEOM **lwpointarr_remove_duplicates(LWGEOM **points, int count, + int *newcount); +extern LWGEOM *lwpointarr_make_trajectory(LWGEOM **points, int count, + interpType interp); +extern LWLINE *lwline_make(Datum value1, Datum value2); +extern LWGEOM *lwcoll_from_points_lines(LWGEOM **points, LWGEOM **lines, + int npoints, int nlines); + +/* Stop function */ + +int tpointseq_stops_iter(const TSequence *seq, double maxdist, int64 mintunits, + TSequence **result); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialrels.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialrels.h new file mode 100644 index 0000000..c8af8a6 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_spatialrels.h @@ -0,0 +1,127 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatial relationships for temporal points. + */ + +#ifndef __TGEO_SPATIALRELS_H__ +#define __TGEO_SPATIALRELS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +#define INVERT_RESULT(result) (result < 0 ? -1 : (result > 0) ? 0 : 1) + +/*****************************************************************************/ + +extern Datum datum_geom_contains(Datum geom1, Datum geom2); +extern Datum datum_geom_covers(Datum geom1, Datum geom2); +extern Datum datum_geom_disjoint2d(Datum geom1, Datum geom2); +extern Datum datum_geom_disjoint3d(Datum geom1, Datum geom2); +extern Datum datum_geog_disjoint(Datum geog1, Datum geog2); +extern Datum datum_geom_intersects2d(Datum geom1, Datum geom2); +extern Datum datum_geom_intersects3d(Datum geom1, Datum geom2); +extern Datum datum_geog_intersects(Datum geog1, Datum geog2); +extern Datum datum_geom_touches(Datum geom1, Datum geom2); +extern Datum datum_geom_dwithin2d(Datum geom1, Datum geom2, Datum dist); +extern Datum datum_geom_dwithin3d(Datum geom1, Datum geom2, Datum dist); +extern Datum datum_geog_dwithin(Datum geog1, Datum geog2, Datum dist); +extern Datum datum_geom_relate_pattern(Datum geog1, Datum geog2, Datum p); +extern Datum datum_geom_touches(Datum geom1, Datum geom2); + +extern datum_func2 geo_disjoint_fn(int16 flags1, int16 flags2); +extern datum_func2 geo_disjoint_fn_geo(int16 flags1, uint8_t flags2); +extern datum_func2 geo_intersects_fn(int16 flags1, int16 flags2); +extern datum_func2 geo_intersects_fn_geo(int16 flags1, uint8_t flags2); +extern datum_func3 geo_dwithin_fn(int16 flags1, int16 flags2); +extern datum_func3 geo_dwithin_fn_geo(int16 flags1, uint8_t flags2); + +/*****************************************************************************/ + +extern int tpointsegm_tdwithin_turnpt(Datum start1, Datum end1, Datum start2, + Datum end2, Datum value, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); + +extern int spatialrel_geo_geo(const GSERIALIZED *gs1, const GSERIALIZED *gs2, + Datum param, varfunc func, int numparam, bool invert); +extern int spatialrel_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, + Datum param, varfunc func, int numparam); + +extern int ea_contains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever); +extern int ea_contains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_contains_tgeo_tgeo(const Temporal *temp, const Temporal *temp2, + bool ever); + +extern int ea_covers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever); +extern int ea_covers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_covers_tgeo_tgeo(const Temporal *temp, const Temporal *temp2, + bool ever); + +extern int ea_disjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever); +extern int ea_disjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_disjoint_tgeo_tgeo(const Temporal *temp, const Temporal *temp2, + bool ever); + +extern int ea_intersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever); +extern int ea_intersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_intersects_tgeo_tgeo(const Temporal *temp, const Temporal *temp2, + bool ever); + +extern int ea_touches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_touches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_touches_tgeo_tgeo(const Temporal *temp, const Temporal *temp2, + bool ever); + +extern int ea_dwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + double dist, bool ever); +extern int ea_dwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, + double dist, bool ever); + +extern int ea_spatialrel_tspatial_geo(const Temporal *temp, + const GSERIALIZED *gs, datum_func2 func, bool ever, bool invert); +extern int ea_spatialrel_tspatial_tspatial(const Temporal *temp1, + const Temporal *temp2, datum_func2 func, bool ever); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tempspatialrels.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tempspatialrels.h new file mode 100644 index 0000000..b157f54 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tempspatialrels.h @@ -0,0 +1,79 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatiotemporal relationships for temporal points. + */ + +#ifndef __TGEO_TEMPSPATIALRELS_H__ +#define __TGEO_TEMPSPATIALRELS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/* Compute either the tintersects or the tdisjoint relationship */ +#define TINTERSECTS true +#define TDISJOINT false + +/*****************************************************************************/ + +extern Temporal *tspatialrel_tspatial_base(const Temporal *temp, + Datum base, Datum param, varfunc func, int numparam, bool invert); +extern Temporal *tspatialrel_tspatial_tspatial(const Temporal *temp1, + const Temporal *temp2, Datum param, varfunc func, int numparam, bool invert); + +extern Temporal *tinterrel_tgeo_geo(const Temporal *temp, + const GSERIALIZED *gs, bool tinter); +extern Temporal *tinterrel_tspatial_base(const Temporal *temp, Datum base, + bool tinter, datum_func2 func); + +extern Temporal *tinterrel_tspatial_base(const Temporal *temp, + Datum base, bool tinter, datum_func2 func); +extern Temporal *tinterrel_tspatial_tspatial(const Temporal *temp1, + const Temporal *temp2, bool tinter); + +extern Temporal *tdwithin_tspatial_tspatial(const Temporal *sync1, + const Temporal *sync2, Datum dist, + datum_func3 func, tpfunc_temp tpfn); + +extern int tdwithin_add_solutions(int solutions, TimestampTz lower, + TimestampTz upper, bool lower_inc, bool upper_inc, bool upper_inc1, + TimestampTz t1, TimestampTz t2, TInstant **instants, TSequence **result); +extern Temporal *tdwithin_tspatial_spatial(const Temporal *temp, Datum base, + Datum dist, datum_func3 func, tpfunc_temp tpfn); +extern Temporal *tdwithin_tspatial_tspatial(const Temporal *sync1, + const Temporal *sync2, Datum dist, + datum_func3 func, tpfunc_temp tpfn); + +/*****************************************************************************/ + +#endif /* __TGEO_TEMPSPATIALRELS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tile.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tile.h new file mode 100644 index 0000000..28829ce --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tgeo_tile.h @@ -0,0 +1,112 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for spatiotemporal bounding boxes. + */ + +#ifndef __TPOINT_TILE_H__ +#define __TPOINT_TILE_H__ + +/* PostGIS */ +#include +/* MEOS */ +#include + +#define MAXDIMS 4 + +/*****************************************************************************/ + +/** + * Structure for storing a bit matrix + */ +typedef struct +{ + int ndims; /**< Number of dimensions */ + int count[MAXDIMS]; /**< Number of elements in each dimension */ + uint8_t byte[1]; /**< beginning of variable-length data */ +} BitMatrix; + +/** + * Struct for storing the state that persists across multiple calls generating + * a multidimensional grid + */ +typedef struct STboxGridState +{ + bool done; /**< True when all tiles have been processed */ + bool hasx; /**< True when tiles have X dimension */ + bool hasz; /**< True when tiles have Z dimension */ + bool hast; /**< True when tiles have T dimension */ + int i; /**< Number of current tile */ + double xsize; /**< Size of the x dimension */ + double ysize; /**< Size of the y dimension */ + double zsize; /**< Size of the z dimension, 0 for 2D */ + int64 tunits; /**< Size of the time dimension, 0 for spatial only */ + STBox box; /**< Bounding box of the grid */ + const Temporal *temp; /**< Optional temporal point to be split */ + BitMatrix *bm; /**< Optional bit matrix for speeding up the + computation of the split functions */ + double x; /**< Minimum x value of the current tile */ + double y; /**< Minimum y value of the current tile */ + double z; /**< Minimum z value of the current tile, if any */ + TimestampTz t; /**< Minimum t value of the current tile, if any */ + int ntiles; /**< Total number of tiles */ + int max_coords[MAXDIMS]; /**< Maximum coordinates of the tiles */ + int coords[MAXDIMS]; /**< Coordinates of the current tile */ +} STboxGridState; + +/*****************************************************************************/ + +extern BitMatrix *bitmatrix_make(int *count, int ndims); +extern int tpoint_set_tiles(const Temporal *temp, const STboxGridState *state, + BitMatrix *bm); +extern Temporal *tpoint_at_tile(const Temporal *temp, const STBox *box); + +extern void stbox_tile_state_set(double x, double y, double z, TimestampTz t, + double xsize, double ysize, double zsize, int64 tunits, bool hasx, bool hasz, + bool hast, int32 srid, STBox *result); +extern STboxGridState *stbox_tile_state_make(const Temporal *temp, + const STBox *box, double xsize, double ysize, double zsize, + const Interval *duration, POINT3DZ sorigin, TimestampTz torigin, + bool border_inc); +extern void stbox_tile_state_next(STboxGridState *state); +extern bool stbox_tile_state_get(STboxGridState *state, STBox *box); + +extern STboxGridState *tgeo_space_time_tile_init(const Temporal *temp, + double xsize, double ysize, double zsize, const Interval *duration, + const GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, + bool border_inc, int *ntiles); + +extern STBox *stbox_space_time_tile(const GSERIALIZED *point, TimestampTz t, + double xsize, double ysize, double zsize, const Interval *duration, + const GSERIALIZED *sorigin, TimestampTz torigin, bool hasx, bool hast); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tpoint_datagen.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tpoint_datagen.h new file mode 100644 index 0000000..6d6fbb1 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tpoint_datagen.h @@ -0,0 +1,49 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for spatiotemporal bounding boxes. + */ + +#ifndef __TPOINT_DATAGEN_H__ +#define __TPOINT_DATAGEN_H__ + +/* MEOS */ +#include +#include + +/*****************************************************************************/ + +extern TSequence *create_trip(LWLINE **lines, const double *maxSpeeds, + const int *categories, uint32_t noEdges, TimestampTz startTime, + bool disturbData, int verbosity); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial.h new file mode 100644 index 0000000..7abd8cb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial.h @@ -0,0 +1,58 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Generic functions for spatiotemporal values + */ + +#ifndef __TSPATIAL_H__ +#define __TSPATIAL_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +extern char **spatialarr_wkt_out(const Datum *spatialarr, MeosType basetype, + int count, int maxdd, bool extended); + +extern char *spatialbase_as_text(Datum value, MeosType type, int maxdd); +extern char *spatialbase_as_ewkt(Datum value, MeosType type, int maxdd); + +extern bool point_transf_pj(GSERIALIZED *gs, int32_t srid_to, const LWPROJ *pj); + +/*****************************************************************************/ + +#endif /* __TSPATIAL_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_boxops.h new file mode 100644 index 0000000..ac6738a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_boxops.h @@ -0,0 +1,73 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Bounding box operators for spatiotemporal values + */ + +#ifndef __TSPATIAL_BOXOPS_H__ +#define __TSPATIAL_BOXOPS_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/* Functions computing the bounding box at the creation of a temporal point */ + +extern void tgeoinst_set_stbox(const TInstant *inst, STBox *box); +extern void tgeoinstarr_set_stbox(TInstant **instants, int count, + STBox *box); +extern void tgeoseq_expand_stbox(TSequence *seq, const TInstant *inst); + +extern void tspatialinst_set_stbox(const TInstant *inst, STBox *box); +extern void tspatialinstarr_set_stbox(TInstant **instants, int count, + bool lower_inc, bool upper_inc, interpType interp, void *box); +extern void tspatialseqarr_set_stbox(TSequence **sequences, int count, + STBox *box); +extern void tspatialseq_expand_stbox(TSequence *seq, const TInstant *inst); + +extern void spatialarr_set_bbox(const Datum *values, MeosType basetype, + int count, void *box); + +/* Generic box functions */ + +extern bool boxop_tspatial_stbox(const Temporal *temp, const STBox *box, + bool (*func)(const STBox *, const STBox *), bool invert); +extern bool boxop_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2, + bool (*func)(const STBox *, const STBox *)); + +/*****************************************************************************/ + +#endif /* __TSPATIAL_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_parser.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_parser.h new file mode 100644 index 0000000..f51054b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/geo/tspatial_parser.h @@ -0,0 +1,66 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for parsing temporal points. + */ + +#ifndef __TSPATIAL_PARSER_H__ +#define __TSPATIAL_PARSER_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +extern bool srid_parse(const char **str, int *srid); +extern bool spatial_parse_elem(const char **str, MeosType temptype, char delim, + int *temp_srid, Datum *result); +extern bool geo_parse(const char **str, MeosType basetype, char delim, + int *srid, GSERIALIZED **result); +extern STBox *stbox_parse(const char **str); +extern Temporal *tpoint_parse(const char **str, MeosType temptype); + +extern TInstant *tspatialinst_parse(const char **str, MeosType temptype, + bool end, int *temp_srid); +extern TSequence *tspatialseq_disc_parse(const char **str, MeosType temptype, + int *temp_srid); +extern TSequence *tspatialseq_cont_parse(const char **str, MeosType temptype, + interpType interp, bool end, int *temp_srid); +extern TSequenceSet *tspatialseqset_parse(const char **str, MeosType temptype, + interpType interp, int *temp_srid); +extern Temporal *tspatial_parse(const char **str, MeosType temptype); + +/*****************************************************************************/ + +#endif /* __TSPATIAL_PARSER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos.h new file mode 100644 index 0000000..044b287 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos.h @@ -0,0 +1,1963 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief External API of the Mobility Engine Open Source (MEOS) library + */ + +#ifndef __MEOS_H__ +#define __MEOS_H__ + +/* C */ +#include +#include +#include +/* PostgreSQL */ +#if MEOS +#include "postgres_int_defs.h" +#else +#include +#include +#include +#endif + +/***************************************************************************** + * Toolchain dependent definitions + *****************************************************************************/ + +#ifdef _MSC_VER +/* + * Under MSVC, functions exported by a loadable module must be marked + * "dllexport". Other compilers don't need that. + * Borrowed from PostgreSQL file win32.h + */ +#define PGDLLEXPORT __declspec (dllexport) +/* + * Avoids warning C4996: 'strdup': The POSIX name for this item is deprecated. + */ +#define strdup _strdup +#endif + +/* + * Thread-local storage qualifier (MEOS_TLS) used internally by MEOS to + * make per-thread state (last-error number, PROJ context, SRS cache, + * ways cache, RNG, session timezone) safe under multithreading. Defined + * in a stand-alone header so that vendored PostgreSQL files can pick it + * up without pulling in the full meos.h. + */ +#include "meos_tls.h" + +/***************************************************************************** + * Type definitions + *****************************************************************************/ + +/** + * @brief Align to double + */ +#define DOUBLE_PAD(size) ( (size) + ((size) % 8 ? (8 - (size) % 8) : 0 ) ) + +/** + * Structure to represent sets of values + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 settype; /**< Set type */ + uint8 basetype; /**< Span basetype */ + int16 flags; /**< Flags */ + int32 count; /**< Number of elements */ + int32 maxcount; /**< Maximum number of elements */ + int16 bboxsize; /**< Size of the bouding box */ +} Set; + +/** + * Structure to represent spans (a.k.a. ranges) + */ +typedef struct +{ + uint8 spantype; /**< span type */ + uint8 basetype; /**< span basetype */ + bool lower_inc; /**< lower bound is inclusive (vs exclusive) */ + bool upper_inc; /**< upper bound is inclusive (vs exclusive) */ + char padding[4]; /**< Not used */ + Datum lower; /**< lower bound value */ + Datum upper; /**< upper bound value */ +} Span; + +/** + * Structure to represent span sets + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 spansettype; /**< Span set type */ + uint8 spantype; /**< Span type */ + uint8 basetype; /**< Span basetype */ + char padding; /**< Not used */ + int32 count; /**< Number of elements */ + int32 maxcount; /**< Maximum number of elements */ + Span span; /**< Bounding span */ + Span elems[1]; /**< Beginning of variable-length data */ +} SpanSet; + +/** + * Structure to represent temporal boxes + */ +typedef struct +{ + Span period; /**< time span */ + Span span; /**< value span */ + int16 flags; /**< flags */ +} TBox; + +/** + * Structure to represent spatiotemporal boxes + */ +typedef struct +{ + Span period; /**< time span */ + double xmin; /**< minimum x value */ + double ymin; /**< minimum y value */ + double zmin; /**< minimum z value */ + double xmax; /**< maximum x value */ + double ymax; /**< maximum y value */ + double zmax; /**< maximum z value */ + int32_t srid; /**< SRID */ + int16 flags; /**< flags */ +} STBox; + +/** + * @brief Enumeration that defines the temporal subtypes used in MEOS + */ +typedef enum +{ + ANYTEMPSUBTYPE = 0, /**< Any temporal subtype */ + TINSTANT = 1, /**< Temporal instant subtype */ + TSEQUENCE = 2, /**< Temporal sequence subtype */ + TSEQUENCESET = 3, /**< Temporal sequence set subtype */ +} tempSubtype; + +/** + * @brief Enumeration that defines the interpolation types used in MEOS + */ +typedef enum +{ + INTERP_NONE = 0, + DISCRETE = 1, + STEP = 2, + LINEAR = 3, +} interpType; + +/** + * Structure to represent the common structure of temporal values of + * any temporal subtype + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 temptype; /**< Temporal type */ + uint8 subtype; /**< Temporal subtype */ + int16 flags; /**< Flags */ + /* variable-length data follows */ +} Temporal; + +/** + * Structure to represent temporal values of instant subtype + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 temptype; /**< Temporal type */ + uint8 subtype; /**< Temporal subtype */ + int16 flags; /**< Flags */ + TimestampTz t; /**< Timestamp (8 bytes) */ + Datum value; /**< Base value for types passed by value, + first 8 bytes of the base value for values + passed by reference. The extra bytes + needed are added upon creation. */ + /* variable-length data follows */ +} TInstant; + +/** + * Structure to represent temporal values of sequence subtype + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 temptype; /**< Temporal type */ + uint8 subtype; /**< Temporal subtype */ + int16 flags; /**< Flags */ + int32 count; /**< Number of TInstant elements */ + int32 maxcount; /**< Maximum number of TInstant elements */ + int16 bboxsize; /**< Size of the bounding box */ + char padding[6]; /**< Not used */ + Span period; /**< Time span (24 bytes). All bounding boxes start + with a period so actually it is also the begining + of the bounding box. The extra bytes needed for + the bounding box are added upon creation. */ + /* variable-length data follows */ +} TSequence; + +#define TSEQUENCE_BBOX_PTR(seq) ((void *)(&(seq)->period)) + +/** + * Structure to represent temporal values of sequence set subtype + */ +typedef struct +{ + int32 vl_len_; /**< Varlena header (do not touch directly!) */ + uint8 temptype; /**< Temporal type */ + uint8 subtype; /**< Temporal subtype */ + int16 flags; /**< Flags */ + int32 count; /**< Number of TSequence elements */ + int32 totalcount; /**< Total number of TInstant elements in all + composing TSequence elements */ + int32 maxcount; /**< Maximum number of TSequence elements */ + int16 bboxsize; /**< Size of the bounding box */ + int16 padding; /**< Not used */ + Span period; /**< Time span (24 bytes). All bounding boxes start + with a period so actually it is also the begining + of the bounding box. The extra bytes needed for + the bounding box are added upon creation. */ + /* variable-length data follows */ +} TSequenceSet; + +#define TSEQUENCESET_BBOX_PTR(ss) ((void *)(&(ss)->period)) + +/** + * Struct for storing a similarity match + */ +typedef struct +{ + int i; + int j; +} Match; + +/*****************************************************************************/ + +/** + * Structure for skiplists + */ +typedef struct SkipList SkipList; + +/*****************************************************************************/ + +/** + * Structure for expandable arrays + */ +typedef struct MeosArray MeosArray; + +/* MeosArray functions */ + +extern MeosArray *meos_array_create(int elem_size); +extern void meos_array_add(MeosArray *array, void *value); +extern void *meos_array_get(const MeosArray *array, int n); +extern int meos_array_count(const MeosArray *array); +extern void meos_array_reset(MeosArray *array); +extern void meos_array_reset_free(MeosArray *array); +extern void meos_array_destroy(MeosArray *array); +extern void meos_array_destroy_free(MeosArray *array); + +/*****************************************************************************/ + +/** + * @brief Enumeration that defines the search operations for an RTree. + */ +typedef enum +{ + RTREE_OVERLAPS, /**< Find stored boxes that overlap the query */ + RTREE_CONTAINS, /**< Find stored boxes that contain the query */ + RTREE_CONTAINED_BY /**< Find stored boxes contained by the query */ +} RTreeSearchOp; + +/** + * Structure for the in-memory Rtree index + */ +typedef struct RTree RTree; + +/* RTree functions */ + +extern RTree *rtree_create_intspan(); +extern RTree *rtree_create_bigintspan(); +extern RTree *rtree_create_floatspan(); +extern RTree *rtree_create_datespan(); +extern RTree *rtree_create_tstzspan(); +extern RTree *rtree_create_tbox(); +extern RTree *rtree_create_stbox(); +#if POINTCLOUD +extern RTree *rtree_create_tpcbox(); +#endif +extern void rtree_free(RTree *rtree); +extern void rtree_insert(RTree *rtree, void *box, int id); +extern void rtree_insert_temporal(RTree *rtree, const Temporal *temp, int id); +extern int rtree_search(const RTree *rtree, RTreeSearchOp op, const void *query, MeosArray *result); +extern int rtree_search_temporal(const RTree *rtree, RTreeSearchOp op, const Temporal *temp, MeosArray *result); + +/***************************************************************************** + * Error codes + *****************************************************************************/ + +typedef enum +{ + MEOS_SUCCESS = 0, // Successful operation + + MEOS_ERR_INTERNAL_ERROR = 1, // Unspecified internal error + MEOS_ERR_INTERNAL_TYPE_ERROR = 2, // Internal type error + MEOS_ERR_VALUE_OUT_OF_RANGE = 3, // Internal out of range error + MEOS_ERR_DIVISION_BY_ZERO = 4, // Internal division by zero error + MEOS_ERR_MEMORY_ALLOC_ERROR = 5, // Internal malloc error + MEOS_ERR_AGGREGATION_ERROR = 6, // Internal aggregation error + MEOS_ERR_DIRECTORY_ERROR = 7, // Internal directory error + MEOS_ERR_FILE_ERROR = 8, // Internal file error + + MEOS_ERR_INVALID_ARG = 10, // Invalid argument + MEOS_ERR_INVALID_ARG_TYPE = 11, // Invalid argument type + MEOS_ERR_INVALID_ARG_VALUE = 12, // Invalid argument value + MEOS_ERR_FEATURE_NOT_SUPPORTED = 13, // Feature not currently supported + + MEOS_ERR_MFJSON_INPUT = 20, // MFJSON input error + MEOS_ERR_MFJSON_OUTPUT = 21, // MFJSON output error + MEOS_ERR_TEXT_INPUT = 22, // Text input error + MEOS_ERR_TEXT_OUTPUT = 23, // Text output error + MEOS_ERR_WKB_INPUT = 24, // WKB input error + MEOS_ERR_WKB_OUTPUT = 25, // WKB output error + MEOS_ERR_GEOJSON_INPUT = 26, // GEOJSON input error + MEOS_ERR_GEOJSON_OUTPUT = 27, // GEOJSON output error + +} errorCode; + +extern void meos_error(int errlevel, int errcode, const char *format, ...); + +/* Set or read error level */ + +extern int meos_errno(void); +extern int meos_errno_set(int err); +extern int meos_errno_restore(int err); +extern int meos_errno_reset(void); + +/***************************************************************************** + * Initialization of the MEOS library + * + * Multithreading + * -------------- + * The MEOS state managed by these functions is per-thread. Each thread + * that calls into MEOS must call `meos_initialize()` before its first + * MEOS call and `meos_finalize()` before exiting; the PROJ context, SRS + * cache, ways cache, RNGs, last-error number (`meos_errno`), and + * session timezone are all thread-local. + * + * The error handler set by `meos_initialize_error_handler()` is the + * one exception: it is process-global and should be installed once + * before workers are spawned. + *****************************************************************************/ + +/* Definition of error handler function */ +typedef void (*error_handler_fn)(int, int, const char *); + +extern void meos_initialize_timezone(const char *name); +extern void meos_initialize_error_handler(error_handler_fn err_handler); +extern void meos_finalize_timezone(void); +extern void meos_finalize_projsrs(void); +extern void meos_finalize_ways(void); + +extern bool meos_set_datestyle(const char *newval, void *extra); +extern bool meos_set_intervalstyle(const char *newval, int extra); +extern char *meos_get_datestyle(void); +extern char *meos_get_intervalstyle(void); + +extern void meos_set_spatial_ref_sys_csv(const char* path); + +extern void meos_initialize(void); +extern void meos_finalize(void); + +/****************************************************************************** + * Functions for base and time types + ******************************************************************************/ + +extern DateADT add_date_int(DateADT d, int32 days); +extern Interval *add_interval_interval(const Interval *interv1, const Interval *interv2); +extern TimestampTz add_timestamptz_interval(TimestampTz t, const Interval *interv); +extern bool bool_in(const char *str); +extern char *bool_out(bool b); +extern text *cstring2text(const char *str); +extern Timestamp date_to_timestamp(DateADT dateVal); +extern TimestampTz date_to_timestamptz(DateADT d); +extern double float_exp(double d); +extern double float_ln(double d); +extern double float_log10(double d); +extern char *float8_out(double d, int maxdd); +extern double float_round(double d, int maxdd); +extern int int32_cmp(int32 l, int32 r); +extern int int64_cmp(int64 l, int64 r); +extern Interval *interval_make(int32 years, int32 months, int32 weeks, int32 days, int32 hours, int32 mins, double secs); +extern int minus_date_date(DateADT d1, DateADT d2); +extern DateADT minus_date_int(DateADT d, int32 days); +extern TimestampTz minus_timestamptz_interval(TimestampTz t, const Interval *interv); +extern Interval *minus_timestamptz_timestamptz(TimestampTz t1, TimestampTz t2); +extern Interval *mul_interval_double(const Interval *interv, double factor); +extern DateADT pg_date_in(const char *str); +extern char *pg_date_out(DateADT d); +extern int pg_interval_cmp(const Interval *interv1, const Interval *interv2); +extern Interval *pg_interval_in(const char *str, int32 typmod); +extern char *pg_interval_out(const Interval *interv); +extern Timestamp pg_timestamp_in(const char *str, int32 typmod); +extern char *pg_timestamp_out(Timestamp t); +extern TimestampTz pg_timestamptz_in(const char *str, int32 typmod); +extern char *pg_timestamptz_out(TimestampTz t); +extern char *text2cstring(const text *txt); +extern int text_cmp(const text *txt1, const text *txt2); +extern text *text_copy(const text *txt); +extern text *text_in(const char *str); +extern text *text_initcap(const text *txt); +extern text *text_lower(const text *txt); +extern char *text_out(const text *txt); +extern text *text_upper(const text *txt); +extern text *textcat_text_text(const text *txt1, const text *txt2); +extern TimestampTz timestamptz_shift(TimestampTz t, const Interval *interv); +extern DateADT timestamp_to_date(Timestamp t); +extern DateADT timestamptz_to_date(TimestampTz t); + +/*============================================================================ + * Functions for set and span types + ===========================================================================*/ + +/***************************************************************************** + * Input/output functions for set and span types + *****************************************************************************/ + +extern Set *bigintset_in(const char *str); +extern char *bigintset_out(const Set *set); +extern Span *bigintspan_expand(const Span *s, int64 value); +extern Span *bigintspan_in(const char *str); +extern char *bigintspan_out(const Span *s); +extern SpanSet *bigintspanset_in(const char *str); +extern char *bigintspanset_out(const SpanSet *ss); +extern Set *dateset_in(const char *str); +extern char *dateset_out(const Set *s); +extern Span *datespan_in(const char *str); +extern char *datespan_out(const Span *s); +extern SpanSet *datespanset_in(const char *str); +extern char *datespanset_out(const SpanSet *ss); +extern Set *floatset_in(const char *str); +extern char *floatset_out(const Set *set, int maxdd); +extern Span *floatspan_expand(const Span *s, double value); +extern Span *floatspan_in(const char *str); +extern char *floatspan_out(const Span *s, int maxdd); +extern SpanSet *floatspanset_in(const char *str); +extern char *floatspanset_out(const SpanSet *ss, int maxdd); +extern Set *intset_in(const char *str); +extern char *intset_out(const Set *set); +extern Span *intspan_expand(const Span *s, int32 value); +extern Span *intspan_in(const char *str); +extern char *intspan_out(const Span *s); +extern SpanSet *intspanset_in(const char *str); +extern char *intspanset_out(const SpanSet *ss); +extern char *set_as_hexwkb(const Set *s, uint8_t variant, size_t *size_out); +extern uint8_t *set_as_wkb(const Set *s, uint8_t variant, size_t *size_out); +extern Set *set_from_hexwkb(const char *hexwkb); +extern Set *set_from_wkb(const uint8_t *wkb, size_t size); +extern char *span_as_hexwkb(const Span *s, uint8_t variant, size_t *size_out); +extern uint8_t *span_as_wkb(const Span *s, uint8_t variant, size_t *size_out); +extern Span *span_from_hexwkb(const char *hexwkb); +extern Span *span_from_wkb(const uint8_t *wkb, size_t size); +extern char *spanset_as_hexwkb(const SpanSet *ss, uint8_t variant, size_t *size_out); +extern uint8_t *spanset_as_wkb(const SpanSet *ss, uint8_t variant, size_t *size_out); +extern SpanSet *spanset_from_hexwkb(const char *hexwkb); +extern SpanSet *spanset_from_wkb(const uint8_t *wkb, size_t size); +extern Set *textset_in(const char *str); +extern char *textset_out(const Set *set); +extern Set *tstzset_in(const char *str); +extern char *tstzset_out(const Set *set); +extern Span *tstzspan_in(const char *str); +extern char *tstzspan_out(const Span *s); +extern SpanSet *tstzspanset_in(const char *str); +extern char *tstzspanset_out(const SpanSet *ss); + +/***************************************************************************** + * Constructor functions for set and span types + *****************************************************************************/ + +extern Set *bigintset_make(const int64 *values, int count); +extern Span *bigintspan_make(int64 lower, int64 upper, bool lower_inc, bool upper_inc); +extern Set *dateset_make(const DateADT *values, int count); +extern Span *datespan_make(DateADT lower, DateADT upper, bool lower_inc, bool upper_inc); +extern Set *floatset_make(const double *values, int count); +extern Span *floatspan_make(double lower, double upper, bool lower_inc, bool upper_inc); +extern Set *intset_make(const int *values, int count); +extern Span *intspan_make(int lower, int upper, bool lower_inc, bool upper_inc); +extern Set *set_copy(const Set *s); +extern Span *span_copy(const Span *s); +extern SpanSet *spanset_copy(const SpanSet *ss); +extern SpanSet *spanset_make(Span *spans, int count); +extern Set *textset_make(text **values, int count); +extern Set *tstzset_make(const TimestampTz *values, int count); +extern Span *tstzspan_make(TimestampTz lower, TimestampTz upper, bool lower_inc, bool upper_inc); + +/***************************************************************************** + * Conversion functions for set and span types + *****************************************************************************/ + +extern Set *bigint_to_set(int64 i); +extern Span *bigint_to_span(int64 i); +extern SpanSet *bigint_to_spanset(int64 i); +extern Span *bigintspan_to_intspan(const Span *s); +extern Span *bigintspan_to_floatspan(const Span *s); +extern Set *date_to_set(DateADT d); +extern Span *date_to_span(DateADT d); +extern SpanSet *date_to_spanset(DateADT d); +extern Set *dateset_to_tstzset(const Set *s); +extern Span *datespan_to_tstzspan(const Span *s); +extern SpanSet *datespanset_to_tstzspanset(const SpanSet *ss); +extern Set *float_to_set(double d); +extern Span *float_to_span(double d); +extern SpanSet *float_to_spanset(double d); +extern Set *floatset_to_intset(const Set *s); +extern Span *floatspan_to_bigintspan(const Span *s); +extern Span *floatspan_to_intspan(const Span *s); +extern SpanSet *floatspanset_to_intspanset(const SpanSet *ss); +extern Set *int_to_set(int i); +extern Span *int_to_span(int i); +extern SpanSet *int_to_spanset(int i); +extern Set *intset_to_floatset(const Set *s); +extern Span *intspan_to_bigintspan(const Span *s); +extern Span *intspan_to_floatspan(const Span *s); +extern SpanSet *intspanset_to_floatspanset(const SpanSet *ss); +extern Span *set_to_span(const Set *s); +extern SpanSet *set_to_spanset(const Set *s); +extern SpanSet *span_to_spanset(const Span *s); +extern Set *text_to_set(const text *txt); +extern Set *timestamptz_to_set(TimestampTz t); +extern Span *timestamptz_to_span(TimestampTz t); +extern SpanSet *timestamptz_to_spanset(TimestampTz t); +extern Set *tstzset_to_dateset(const Set *s); +extern Span *tstzspan_to_datespan(const Span *s); +extern SpanSet *tstzspanset_to_datespanset(const SpanSet *ss); + +/***************************************************************************** + * Accessor functions for set and span types + *****************************************************************************/ + +extern int64 bigintset_end_value(const Set *s); +extern int64 bigintset_start_value(const Set *s); +extern bool bigintset_value_n(const Set *s, int n, int64 *result); +extern int64 *bigintset_values(const Set *s); +extern int64 bigintspan_lower(const Span *s); +extern int64 bigintspan_upper(const Span *s); +extern int64 bigintspan_width(const Span *s); +extern int64 bigintspanset_lower(const SpanSet *ss); +extern int64 bigintspanset_upper(const SpanSet *ss); +extern int64 bigintspanset_width(const SpanSet *ss, bool boundspan); +extern DateADT dateset_end_value(const Set *s); +extern DateADT dateset_start_value(const Set *s); +extern bool dateset_value_n(const Set *s, int n, DateADT *result); +extern DateADT *dateset_values(const Set *s); +extern Interval *datespan_duration(const Span *s); +extern DateADT datespan_lower(const Span *s); +extern DateADT datespan_upper(const Span *s); +extern bool datespanset_date_n(const SpanSet *ss, int n, DateADT *result); +extern Set *datespanset_dates(const SpanSet *ss); +extern Interval *datespanset_duration(const SpanSet *ss, bool boundspan); +extern DateADT datespanset_end_date(const SpanSet *ss); +extern int datespanset_num_dates(const SpanSet *ss); +extern DateADT datespanset_start_date(const SpanSet *ss); +extern double floatset_end_value(const Set *s); +extern double floatset_start_value(const Set *s); +extern bool floatset_value_n(const Set *s, int n, double *result); +extern double *floatset_values(const Set *s); +extern double floatspan_lower(const Span *s); +extern double floatspan_upper(const Span *s); +extern double floatspan_width(const Span *s); +extern double floatspanset_lower(const SpanSet *ss); +extern double floatspanset_upper(const SpanSet *ss); +extern double floatspanset_width(const SpanSet *ss, bool boundspan); +extern int intset_end_value(const Set *s); +extern int intset_start_value(const Set *s); +extern bool intset_value_n(const Set *s, int n, int *result); +extern int *intset_values(const Set *s); +extern int intspan_lower(const Span *s); +extern int intspan_upper(const Span *s); +extern int intspan_width(const Span *s); +extern int intspanset_lower(const SpanSet *ss); +extern int intspanset_upper(const SpanSet *ss); +extern int intspanset_width(const SpanSet *ss, bool boundspan); +extern uint32 set_hash(const Set *s); +extern uint64 set_hash_extended(const Set *s, uint64 seed); +extern int set_num_values(const Set *s); +extern uint32 span_hash(const Span *s); +extern uint64 span_hash_extended(const Span *s, uint64 seed); +extern bool span_lower_inc(const Span *s); +extern bool span_upper_inc(const Span *s); +extern Span *spanset_end_span(const SpanSet *ss); +extern uint32 spanset_hash(const SpanSet *ss); +extern uint64 spanset_hash_extended(const SpanSet *ss, uint64 seed); +extern bool spanset_lower_inc(const SpanSet *ss); +extern int spanset_num_spans(const SpanSet *ss); +extern Span *spanset_span(const SpanSet *ss); +extern Span *spanset_span_n(const SpanSet *ss, int i); +extern Span **spanset_spanarr(const SpanSet *ss); +extern Span *spanset_start_span(const SpanSet *ss); +extern bool spanset_upper_inc(const SpanSet *ss); +extern text *textset_end_value(const Set *s); +extern text *textset_start_value(const Set *s); +extern bool textset_value_n(const Set *s, int n, text **result); +extern text **textset_values(const Set *s); +extern TimestampTz tstzset_end_value(const Set *s); +extern TimestampTz tstzset_start_value(const Set *s); +extern bool tstzset_value_n(const Set *s, int n, TimestampTz *result); +extern TimestampTz *tstzset_values(const Set *s); +extern Interval *tstzspan_duration(const Span *s); +extern TimestampTz tstzspan_lower(const Span *s); +extern TimestampTz tstzspan_upper(const Span *s); +extern Interval *tstzspanset_duration(const SpanSet *ss, bool boundspan); +extern TimestampTz tstzspanset_end_timestamptz(const SpanSet *ss); +extern TimestampTz tstzspanset_lower(const SpanSet *ss); +extern int tstzspanset_num_timestamps(const SpanSet *ss); +extern TimestampTz tstzspanset_start_timestamptz(const SpanSet *ss); +extern Set *tstzspanset_timestamps(const SpanSet *ss); +extern bool tstzspanset_timestamptz_n(const SpanSet *ss, int n, TimestampTz *result); +extern TimestampTz tstzspanset_upper(const SpanSet *ss); + +/***************************************************************************** + * Transformation functions for set and span types + *****************************************************************************/ + +extern Set *bigintset_shift_scale(const Set *s, int64 shift, int64 width, bool hasshift, bool haswidth); +extern Span *bigintspan_shift_scale(const Span *s, int64 shift, int64 width, bool hasshift, bool haswidth); +extern SpanSet *bigintspanset_shift_scale(const SpanSet *ss, int64 shift, int64 width, bool hasshift, bool haswidth); +extern Set *dateset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); +extern Span *datespan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); +extern SpanSet *datespanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); +extern Set *floatset_ceil(const Set *s); +extern Set *floatset_degrees(const Set *s, bool normalize); +extern Set *floatset_floor(const Set *s); +extern Set *floatset_radians(const Set *s); +extern Set *floatset_shift_scale(const Set *s, double shift, double width, bool hasshift, bool haswidth); +extern Span *floatspan_ceil(const Span *s); +extern Span *floatspan_degrees(const Span *s, bool normalize); +extern Span *floatspan_floor(const Span *s); +extern Span *floatspan_radians(const Span *s); +extern Span *floatspan_round(const Span *s, int maxdd); +extern Span *floatspan_shift_scale(const Span *s, double shift, double width, bool hasshift, bool haswidth); +extern SpanSet *floatspanset_ceil(const SpanSet *ss); +extern SpanSet *floatspanset_floor(const SpanSet *ss); +extern SpanSet *floatspanset_degrees(const SpanSet *ss, bool normalize); +extern SpanSet *floatspanset_radians(const SpanSet *ss); +extern SpanSet *floatspanset_round(const SpanSet *ss, int maxdd); +extern SpanSet *floatspanset_shift_scale(const SpanSet *ss, double shift, double width, bool hasshift, bool haswidth); +extern Set *intset_shift_scale(const Set *s, int shift, int width, bool hasshift, bool haswidth); +extern Span *intspan_shift_scale(const Span *s, int shift, int width, bool hasshift, bool haswidth); +extern SpanSet *intspanset_shift_scale(const SpanSet *ss, int shift, int width, bool hasshift, bool haswidth); +extern Span *tstzspan_expand(const Span *s, const Interval *interv); +extern Set *set_round(const Set *s, int maxdd); +extern Set *textcat_text_textset(const text *txt, const Set *s); +extern Set *textcat_textset_text(const Set *s, const text *txt); +extern Set *textset_initcap(const Set *s); +extern Set *textset_lower(const Set *s); +extern Set *textset_upper(const Set *s); +extern TimestampTz timestamptz_tprecision(TimestampTz t, const Interval *duration, TimestampTz torigin); +extern Set *tstzset_shift_scale(const Set *s, const Interval *shift, const Interval *duration); +extern Set *tstzset_tprecision(const Set *s, const Interval *duration, TimestampTz torigin); +extern Span *tstzspan_shift_scale(const Span *s, const Interval *shift, const Interval *duration); +extern Span *tstzspan_tprecision(const Span *s, const Interval *duration, TimestampTz torigin); +extern SpanSet *tstzspanset_shift_scale(const SpanSet *ss, const Interval *shift, const Interval *duration); +extern SpanSet *tstzspanset_tprecision(const SpanSet *ss, const Interval *duration, TimestampTz torigin); + +/***************************************************************************** + * Comparison functions for set and span types + *****************************************************************************/ + +extern int set_cmp(const Set *s1, const Set *s2); +extern bool set_eq(const Set *s1, const Set *s2); +extern bool set_ge(const Set *s1, const Set *s2); +extern bool set_gt(const Set *s1, const Set *s2); +extern bool set_le(const Set *s1, const Set *s2); +extern bool set_lt(const Set *s1, const Set *s2); +extern bool set_ne(const Set *s1, const Set *s2); +extern int span_cmp(const Span *s1, const Span *s2); +extern bool span_eq(const Span *s1, const Span *s2); +extern bool span_ge(const Span *s1, const Span *s2); +extern bool span_gt(const Span *s1, const Span *s2); +extern bool span_le(const Span *s1, const Span *s2); +extern bool span_lt(const Span *s1, const Span *s2); +extern bool span_ne(const Span *s1, const Span *s2); +extern int spanset_cmp(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_eq(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_ge(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_gt(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_le(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_lt(const SpanSet *ss1, const SpanSet *ss2); +extern bool spanset_ne(const SpanSet *ss1, const SpanSet *ss2); + +/***************************************************************************** + * Bounding box functions for set and span types + *****************************************************************************/ + +/* Split functions */ + +extern Span *set_spans(const Set *s); +extern Span *set_split_each_n_spans(const Set *s, int elems_per_span, int *count); +extern Span *set_split_n_spans(const Set *s, int span_count, int *count); +extern Span *spanset_spans(const SpanSet *ss); +extern Span *spanset_split_each_n_spans(const SpanSet *ss, int elems_per_span, int *count); +extern Span *spanset_split_n_spans(const SpanSet *ss, int span_count, int *count); + +/* Topological functions */ + +extern bool adjacent_span_bigint(const Span *s, int64 i); +extern bool adjacent_span_date(const Span *s, DateADT d); +extern bool adjacent_span_float(const Span *s, double d); +extern bool adjacent_span_int(const Span *s, int i); +extern bool adjacent_span_span(const Span *s1, const Span *s2); +extern bool adjacent_span_spanset(const Span *s, const SpanSet *ss); +extern bool adjacent_span_timestamptz(const Span *s, TimestampTz t); +extern bool adjacent_spanset_bigint(const SpanSet *ss, int64 i); +extern bool adjacent_spanset_date(const SpanSet *ss, DateADT d); +extern bool adjacent_spanset_float(const SpanSet *ss, double d); +extern bool adjacent_spanset_int(const SpanSet *ss, int i); +extern bool adjacent_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool adjacent_spanset_span(const SpanSet *ss, const Span *s); +extern bool adjacent_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool contained_bigint_set(int64 i, const Set *s); +extern bool contained_bigint_span(int64 i, const Span *s); +extern bool contained_bigint_spanset(int64 i, const SpanSet *ss); +extern bool contained_date_set(DateADT d, const Set *s); +extern bool contained_date_span(DateADT d, const Span *s); +extern bool contained_date_spanset(DateADT d, const SpanSet *ss); +extern bool contained_float_set(double d, const Set *s); +extern bool contained_float_span(double d, const Span *s); +extern bool contained_float_spanset(double d, const SpanSet *ss); +extern bool contained_int_set(int i, const Set *s); +extern bool contained_int_span(int i, const Span *s); +extern bool contained_int_spanset(int i, const SpanSet *ss); +extern bool contained_set_set(const Set *s1, const Set *s2); +extern bool contained_span_span(const Span *s1, const Span *s2); +extern bool contained_span_spanset(const Span *s, const SpanSet *ss); +extern bool contained_spanset_span(const SpanSet *ss, const Span *s); +extern bool contained_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool contained_text_set(const text *txt, const Set *s); +extern bool contained_timestamptz_set(TimestampTz t, const Set *s); +extern bool contained_timestamptz_span(TimestampTz t, const Span *s); +extern bool contained_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool contains_set_bigint(const Set *s, int64 i); +extern bool contains_set_date(const Set *s, DateADT d); +extern bool contains_set_float(const Set *s, double d); +extern bool contains_set_int(const Set *s, int i); +extern bool contains_set_set(const Set *s1, const Set *s2); +extern bool contains_set_text(const Set *s, text *t); +extern bool contains_set_timestamptz(const Set *s, TimestampTz t); +extern bool contains_span_bigint(const Span *s, int64 i); +extern bool contains_span_date(const Span *s, DateADT d); +extern bool contains_span_float(const Span *s, double d); +extern bool contains_span_int(const Span *s, int i); +extern bool contains_span_span(const Span *s1, const Span *s2); +extern bool contains_span_spanset(const Span *s, const SpanSet *ss); +extern bool contains_span_timestamptz(const Span *s, TimestampTz t); +extern bool contains_spanset_bigint(const SpanSet *ss, int64 i); +extern bool contains_spanset_date(const SpanSet *ss, DateADT d); +extern bool contains_spanset_float(const SpanSet *ss, double d); +extern bool contains_spanset_int(const SpanSet *ss, int i); +extern bool contains_spanset_span(const SpanSet *ss, const Span *s); +extern bool contains_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool contains_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overlaps_set_set(const Set *s1, const Set *s2); +extern bool overlaps_span_span(const Span *s1, const Span *s2); +extern bool overlaps_span_spanset(const Span *s, const SpanSet *ss); +extern bool overlaps_spanset_span(const SpanSet *ss, const Span *s); +extern bool overlaps_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); + +/*****************************************************************************/ + +/* Position functions for set and span types */ + +extern bool after_date_set(DateADT d, const Set *s); +extern bool after_date_span(DateADT d, const Span *s); +extern bool after_date_spanset(DateADT d, const SpanSet *ss); +extern bool after_set_date(const Set *s, DateADT d); +extern bool after_set_timestamptz(const Set *s, TimestampTz t); +extern bool after_span_date(const Span *s, DateADT d); +extern bool after_span_timestamptz(const Span *s, TimestampTz t); +extern bool after_spanset_date(const SpanSet *ss, DateADT d); +extern bool after_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool after_timestamptz_set(TimestampTz t, const Set *s); +extern bool after_timestamptz_span(TimestampTz t, const Span *s); +extern bool after_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool before_date_set(DateADT d, const Set *s); +extern bool before_date_span(DateADT d, const Span *s); +extern bool before_date_spanset(DateADT d, const SpanSet *ss); +extern bool before_set_date(const Set *s, DateADT d); +extern bool before_set_timestamptz(const Set *s, TimestampTz t); +extern bool before_span_date(const Span *s, DateADT d); +extern bool before_span_timestamptz(const Span *s, TimestampTz t); +extern bool before_spanset_date(const SpanSet *ss, DateADT d); +extern bool before_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool before_timestamptz_set(TimestampTz t, const Set *s); +extern bool before_timestamptz_span(TimestampTz t, const Span *s); +extern bool before_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool left_bigint_set(int64 i, const Set *s); +extern bool left_bigint_span(int64 i, const Span *s); +extern bool left_bigint_spanset(int64 i, const SpanSet *ss); +extern bool left_float_set(double d, const Set *s); +extern bool left_float_span(double d, const Span *s); +extern bool left_float_spanset(double d, const SpanSet *ss); +extern bool left_int_set(int i, const Set *s); +extern bool left_int_span(int i, const Span *s); +extern bool left_int_spanset(int i, const SpanSet *ss); +extern bool left_set_bigint(const Set *s, int64 i); +extern bool left_set_float(const Set *s, double d); +extern bool left_set_int(const Set *s, int i); +extern bool left_set_set(const Set *s1, const Set *s2); +extern bool left_set_text(const Set *s, text *txt); +extern bool left_span_bigint(const Span *s, int64 i); +extern bool left_span_float(const Span *s, double d); +extern bool left_span_int(const Span *s, int i); +extern bool left_span_span(const Span *s1, const Span *s2); +extern bool left_span_spanset(const Span *s, const SpanSet *ss); +extern bool left_spanset_bigint(const SpanSet *ss, int64 i); +extern bool left_spanset_float(const SpanSet *ss, double d); +extern bool left_spanset_int(const SpanSet *ss, int i); +extern bool left_spanset_span(const SpanSet *ss, const Span *s); +extern bool left_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool left_text_set(const text *txt, const Set *s); +extern bool overafter_date_set(DateADT d, const Set *s); +extern bool overafter_date_span(DateADT d, const Span *s); +extern bool overafter_date_spanset(DateADT d, const SpanSet *ss); +extern bool overafter_set_date(const Set *s, DateADT d); +extern bool overafter_set_timestamptz(const Set *s, TimestampTz t); +extern bool overafter_span_date(const Span *s, DateADT d); +extern bool overafter_span_timestamptz(const Span *s, TimestampTz t); +extern bool overafter_spanset_date(const SpanSet *ss, DateADT d); +extern bool overafter_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overafter_timestamptz_set(TimestampTz t, const Set *s); +extern bool overafter_timestamptz_span(TimestampTz t, const Span *s); +extern bool overafter_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool overbefore_date_set(DateADT d, const Set *s); +extern bool overbefore_date_span(DateADT d, const Span *s); +extern bool overbefore_date_spanset(DateADT d, const SpanSet *ss); +extern bool overbefore_set_date(const Set *s, DateADT d); +extern bool overbefore_set_timestamptz(const Set *s, TimestampTz t); +extern bool overbefore_span_date(const Span *s, DateADT d); +extern bool overbefore_span_timestamptz(const Span *s, TimestampTz t); +extern bool overbefore_spanset_date(const SpanSet *ss, DateADT d); +extern bool overbefore_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern bool overbefore_timestamptz_set(TimestampTz t, const Set *s); +extern bool overbefore_timestamptz_span(TimestampTz t, const Span *s); +extern bool overbefore_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern bool overleft_bigint_set(int64 i, const Set *s); +extern bool overleft_bigint_span(int64 i, const Span *s); +extern bool overleft_bigint_spanset(int64 i, const SpanSet *ss); +extern bool overleft_float_set(double d, const Set *s); +extern bool overleft_float_span(double d, const Span *s); +extern bool overleft_float_spanset(double d, const SpanSet *ss); +extern bool overleft_int_set(int i, const Set *s); +extern bool overleft_int_span(int i, const Span *s); +extern bool overleft_int_spanset(int i, const SpanSet *ss); +extern bool overleft_set_bigint(const Set *s, int64 i); +extern bool overleft_set_float(const Set *s, double d); +extern bool overleft_set_int(const Set *s, int i); +extern bool overleft_set_set(const Set *s1, const Set *s2); +extern bool overleft_set_text(const Set *s, text *txt); +extern bool overleft_span_bigint(const Span *s, int64 i); +extern bool overleft_span_float(const Span *s, double d); +extern bool overleft_span_int(const Span *s, int i); +extern bool overleft_span_span(const Span *s1, const Span *s2); +extern bool overleft_span_spanset(const Span *s, const SpanSet *ss); +extern bool overleft_spanset_bigint(const SpanSet *ss, int64 i); +extern bool overleft_spanset_float(const SpanSet *ss, double d); +extern bool overleft_spanset_int(const SpanSet *ss, int i); +extern bool overleft_spanset_span(const SpanSet *ss, const Span *s); +extern bool overleft_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool overleft_text_set(const text *txt, const Set *s); +extern bool overright_bigint_set(int64 i, const Set *s); +extern bool overright_bigint_span(int64 i, const Span *s); +extern bool overright_bigint_spanset(int64 i, const SpanSet *ss); +extern bool overright_float_set(double d, const Set *s); +extern bool overright_float_span(double d, const Span *s); +extern bool overright_float_spanset(double d, const SpanSet *ss); +extern bool overright_int_set(int i, const Set *s); +extern bool overright_int_span(int i, const Span *s); +extern bool overright_int_spanset(int i, const SpanSet *ss); +extern bool overright_set_bigint(const Set *s, int64 i); +extern bool overright_set_float(const Set *s, double d); +extern bool overright_set_int(const Set *s, int i); +extern bool overright_set_set(const Set *s1, const Set *s2); +extern bool overright_set_text(const Set *s, text *txt); +extern bool overright_span_bigint(const Span *s, int64 i); +extern bool overright_span_float(const Span *s, double d); +extern bool overright_span_int(const Span *s, int i); +extern bool overright_span_span(const Span *s1, const Span *s2); +extern bool overright_span_spanset(const Span *s, const SpanSet *ss); +extern bool overright_spanset_bigint(const SpanSet *ss, int64 i); +extern bool overright_spanset_float(const SpanSet *ss, double d); +extern bool overright_spanset_int(const SpanSet *ss, int i); +extern bool overright_spanset_span(const SpanSet *ss, const Span *s); +extern bool overright_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool overright_text_set(const text *txt, const Set *s); +extern bool right_bigint_set(int64 i, const Set *s); +extern bool right_bigint_span(int64 i, const Span *s); +extern bool right_bigint_spanset(int64 i, const SpanSet *ss); +extern bool right_float_set(double d, const Set *s); +extern bool right_float_span(double d, const Span *s); +extern bool right_float_spanset(double d, const SpanSet *ss); +extern bool right_int_set(int i, const Set *s); +extern bool right_int_span(int i, const Span *s); +extern bool right_int_spanset(int i, const SpanSet *ss); +extern bool right_set_bigint(const Set *s, int64 i); +extern bool right_set_float(const Set *s, double d); +extern bool right_set_int(const Set *s, int i); +extern bool right_set_set(const Set *s1, const Set *s2); +extern bool right_set_text(const Set *s, text *txt); +extern bool right_span_bigint(const Span *s, int64 i); +extern bool right_span_float(const Span *s, double d); +extern bool right_span_int(const Span *s, int i); +extern bool right_span_span(const Span *s1, const Span *s2); +extern bool right_span_spanset(const Span *s, const SpanSet *ss); +extern bool right_spanset_bigint(const SpanSet *ss, int64 i); +extern bool right_spanset_float(const SpanSet *ss, double d); +extern bool right_spanset_int(const SpanSet *ss, int i); +extern bool right_spanset_span(const SpanSet *ss, const Span *s); +extern bool right_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern bool right_text_set(const text *txt, const Set *s); + +/***************************************************************************** + * Set functions for set and span types + *****************************************************************************/ + +extern Set *intersection_bigint_set(int64 i, const Set *s); +extern Set *intersection_date_set(DateADT d, const Set *s); +extern Set *intersection_float_set(double d, const Set *s); +extern Set *intersection_int_set(int i, const Set *s); +extern Set *intersection_set_bigint(const Set *s, int64 i); +extern Set *intersection_set_date(const Set *s, DateADT d); +extern Set *intersection_set_float(const Set *s, double d); +extern Set *intersection_set_int(const Set *s, int i); +extern Set *intersection_set_set(const Set *s1, const Set *s2); +extern Set *intersection_set_text(const Set *s, const text *txt); +extern Set *intersection_set_timestamptz(const Set *s, TimestampTz t); +extern Span *intersection_span_bigint(const Span *s, int64 i); +extern Span *intersection_span_date(const Span *s, DateADT d); +extern Span *intersection_span_float(const Span *s, double d); +extern Span *intersection_span_int(const Span *s, int i); +extern Span *intersection_span_span(const Span *s1, const Span *s2); +extern SpanSet *intersection_span_spanset(const Span *s, const SpanSet *ss); +extern Span *intersection_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *intersection_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *intersection_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *intersection_spanset_float(const SpanSet *ss, double d); +extern SpanSet *intersection_spanset_int(const SpanSet *ss, int i); +extern SpanSet *intersection_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *intersection_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *intersection_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *intersection_text_set(const text *txt, const Set *s); +extern Set *intersection_timestamptz_set(TimestampTz t, const Set *s); +extern Set *minus_bigint_set(int64 i, const Set *s); +extern SpanSet *minus_bigint_span(int64 i, const Span *s); +extern SpanSet *minus_bigint_spanset(int64 i, const SpanSet *ss); +extern Set *minus_date_set(DateADT d, const Set *s); +extern SpanSet *minus_date_span(DateADT d, const Span *s); +extern SpanSet *minus_date_spanset(DateADT d, const SpanSet *ss); +extern Set *minus_float_set(double d, const Set *s); +extern SpanSet *minus_float_span(double d, const Span *s); +extern SpanSet *minus_float_spanset(double d, const SpanSet *ss); +extern Set *minus_int_set(int i, const Set *s); +extern SpanSet *minus_int_span(int i, const Span *s); +extern SpanSet *minus_int_spanset(int i, const SpanSet *ss); +extern Set *minus_set_bigint(const Set *s, int64 i); +extern Set *minus_set_date(const Set *s, DateADT d); +extern Set *minus_set_float(const Set *s, double d); +extern Set *minus_set_int(const Set *s, int i); +extern Set *minus_set_set(const Set *s1, const Set *s2); +extern Set *minus_set_text(const Set *s, const text *txt); +extern Set *minus_set_timestamptz(const Set *s, TimestampTz t); +extern SpanSet *minus_span_bigint(const Span *s, int64 i); +extern SpanSet *minus_span_date(const Span *s, DateADT d); +extern SpanSet *minus_span_float(const Span *s, double d); +extern SpanSet *minus_span_int(const Span *s, int i); +extern SpanSet *minus_span_span(const Span *s1, const Span *s2); +extern SpanSet *minus_span_spanset(const Span *s, const SpanSet *ss); +extern SpanSet *minus_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *minus_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *minus_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *minus_spanset_float(const SpanSet *ss, double d); +extern SpanSet *minus_spanset_int(const SpanSet *ss, int i); +extern SpanSet *minus_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *minus_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *minus_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *minus_text_set(const text *txt, const Set *s); +extern Set *minus_timestamptz_set(TimestampTz t, const Set *s); +extern SpanSet *minus_timestamptz_span(TimestampTz t, const Span *s); +extern SpanSet *minus_timestamptz_spanset(TimestampTz t, const SpanSet *ss); +extern Set *union_bigint_set(int64 i, const Set *s); +extern SpanSet *union_bigint_span(const Span *s, int64 i); +extern SpanSet *union_bigint_spanset(int64 i, SpanSet *ss); +extern Set *union_date_set(DateADT d, const Set *s); +extern SpanSet *union_date_span(const Span *s, DateADT d); +extern SpanSet *union_date_spanset(DateADT d, SpanSet *ss); +extern Set *union_float_set(double d, const Set *s); +extern SpanSet *union_float_span(const Span *s, double d); +extern SpanSet *union_float_spanset(double d, SpanSet *ss); +extern Set *union_int_set(int i, const Set *s); +extern SpanSet *union_int_span(int i, const Span *s); +extern SpanSet *union_int_spanset(int i, SpanSet *ss); +extern Set *union_set_bigint(const Set *s, int64 i); +extern Set *union_set_date(const Set *s, DateADT d); +extern Set *union_set_float(const Set *s, double d); +extern Set *union_set_int(const Set *s, int i); +extern Set *union_set_set(const Set *s1, const Set *s2); +extern Set *union_set_text(const Set *s, const text *txt); +extern Set *union_set_timestamptz(const Set *s, TimestampTz t); +extern SpanSet *union_span_bigint(const Span *s, int64 i); +extern SpanSet *union_span_date(const Span *s, DateADT d); +extern SpanSet *union_span_float(const Span *s, double d); +extern SpanSet *union_span_int(const Span *s, int i); +extern SpanSet *union_span_span(const Span *s1, const Span *s2); +extern SpanSet *union_span_spanset(const Span *s, const SpanSet *ss); +extern SpanSet *union_span_timestamptz(const Span *s, TimestampTz t); +extern SpanSet *union_spanset_bigint(const SpanSet *ss, int64 i); +extern SpanSet *union_spanset_date(const SpanSet *ss, DateADT d); +extern SpanSet *union_spanset_float(const SpanSet *ss, double d); +extern SpanSet *union_spanset_int(const SpanSet *ss, int i); +extern SpanSet *union_spanset_span(const SpanSet *ss, const Span *s); +extern SpanSet *union_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern SpanSet *union_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern Set *union_text_set(const text *txt, const Set *s); +extern Set *union_timestamptz_set(TimestampTz t, const Set *s); +extern SpanSet *union_timestamptz_span(TimestampTz t, const Span *s); +extern SpanSet *union_timestamptz_spanset(TimestampTz t, SpanSet *ss); + +/***************************************************************************** + * Distance functions for set and span types + *****************************************************************************/ + +extern int64 distance_bigintset_bigintset(const Set *s1, const Set *s2); +extern int64 distance_bigintspan_bigintspan(const Span *s1, const Span *s2); +extern int64 distance_bigintspanset_bigintspan(const SpanSet *ss, const Span *s); +extern int64 distance_bigintspanset_bigintspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int distance_dateset_dateset(const Set *s1, const Set *s2); +extern int distance_datespan_datespan(const Span *s1, const Span *s2); +extern int distance_datespanset_datespan(const SpanSet *ss, const Span *s); +extern int distance_datespanset_datespanset(const SpanSet *ss1, const SpanSet *ss2); +extern double distance_floatset_floatset(const Set *s1, const Set *s2); +extern double distance_floatspan_floatspan(const Span *s1, const Span *s2); +extern double distance_floatspanset_floatspan(const SpanSet *ss, const Span *s); +extern double distance_floatspanset_floatspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int distance_intset_intset(const Set *s1, const Set *s2); +extern int distance_intspan_intspan(const Span *s1, const Span *s2); +extern int distance_intspanset_intspan(const SpanSet *ss, const Span *s); +extern int distance_intspanset_intspanset(const SpanSet *ss1, const SpanSet *ss2); +extern int64 distance_set_bigint(const Set *s, int64 i); +extern int distance_set_date(const Set *s, DateADT d); +extern double distance_set_float(const Set *s, double d); +extern int distance_set_int(const Set *s, int i); +extern double distance_set_timestamptz(const Set *s, TimestampTz t); +extern int64 distance_span_bigint(const Span *s, int64 i); +extern int distance_span_date(const Span *s, DateADT d); +extern double distance_span_float(const Span *s, double d); +extern int distance_span_int(const Span *s, int i); +extern double distance_span_timestamptz(const Span *s, TimestampTz t); +extern int64 distance_spanset_bigint(const SpanSet *ss, int64 i); +extern int distance_spanset_date(const SpanSet *ss, DateADT d); +extern double distance_spanset_float(const SpanSet *ss, double d); +extern int distance_spanset_int(const SpanSet *ss, int i); +extern double distance_spanset_timestamptz(const SpanSet *ss, TimestampTz t); +extern double distance_tstzset_tstzset(const Set *s1, const Set *s2); +extern double distance_tstzspan_tstzspan(const Span *s1, const Span *s2); +extern double distance_tstzspanset_tstzspan(const SpanSet *ss, const Span *s); +extern double distance_tstzspanset_tstzspanset(const SpanSet *ss1, const SpanSet *ss2); + +/***************************************************************************** + * Aggregate functions for set and span types + *****************************************************************************/ + +extern Span *bigint_extent_transfn(Span *state, int64 i); +extern Set *bigint_union_transfn(Set *state, int64 i); +extern Span *date_extent_transfn(Span *state, DateADT d); +extern Set *date_union_transfn(Set *state, DateADT d); +extern Span *float_extent_transfn(Span *state, double d); +extern Set *float_union_transfn(Set *state, double d); +extern Span *int_extent_transfn(Span *state, int i); +extern Set *int_union_transfn(Set *state, int32 i); +extern Span *set_extent_transfn(Span *state, const Set *s); +extern Set *set_union_finalfn(Set *state); +extern Set *set_union_transfn(Set *state, Set *s); +extern Span *span_extent_transfn(Span *state, const Span *s); +extern SpanSet *span_union_transfn(SpanSet *state, const Span *s); +extern Span *spanset_extent_transfn(Span *state, const SpanSet *ss); +extern SpanSet *spanset_union_finalfn(SpanSet *state); +extern SpanSet *spanset_union_transfn(SpanSet *state, const SpanSet *ss); +extern Set *text_union_transfn(Set *state, const text *txt); +extern Span *timestamptz_extent_transfn(Span *state, TimestampTz t); +extern Set *timestamptz_union_transfn(Set *state, TimestampTz t); + +/***************************************************************************** + * Bin functions for span and spanset types + *****************************************************************************/ + +extern int64 bigint_get_bin(int64 value, int64 vsize, int64 vorigin); +extern Span *bigintspan_bins(const Span *s, int64 vsize, int64 vorigin, int *count); +extern Span *bigintspanset_bins(const SpanSet *ss, int64 vsize, int64 vorigin, int *count); +extern DateADT date_get_bin(DateADT d, const Interval *duration, DateADT torigin); +extern Span *datespan_bins(const Span *s, const Interval *duration, DateADT torigin, int *count); +extern Span *datespanset_bins(const SpanSet *ss, const Interval *duration, DateADT torigin, int *count); +extern double float_get_bin(double value, double vsize, double vorigin); +extern Span *floatspan_bins(const Span *s, double vsize, double vorigin, int *count); +extern Span *floatspanset_bins(const SpanSet *ss, double vsize, double vorigin, int *count); +extern int int_get_bin(int value, int vsize, int vorigin); +extern Span *intspan_bins(const Span *s, int vsize, int vorigin, int *count); +extern Span *intspanset_bins(const SpanSet *ss, int vsize, int vorigin, int *count); +extern TimestampTz timestamptz_get_bin(TimestampTz t, const Interval *duration, TimestampTz torigin); +extern Span *tstzspan_bins(const Span *s, const Interval *duration, TimestampTz origin, int *count); +extern Span *tstzspanset_bins(const SpanSet *ss, const Interval *duration, TimestampTz torigin, int *count); + +/*===========================================================================* + * Functions for temporal boxes + *===========================================================================*/ + +/***************************************************************************** + * Input and output functions for box types + *****************************************************************************/ + +extern char *tbox_as_hexwkb(const TBox *box, uint8_t variant, size_t *size); +extern uint8_t *tbox_as_wkb(const TBox *box, uint8_t variant, size_t *size_out); +extern TBox *tbox_from_hexwkb(const char *hexwkb); +extern TBox *tbox_from_wkb(const uint8_t *wkb, size_t size); +extern TBox *tbox_in(const char *str); +extern char *tbox_out(const TBox *box, int maxdd); + +/***************************************************************************** + * Constructor functions for box types + *****************************************************************************/ + +extern TBox *float_timestamptz_to_tbox(double d, TimestampTz t); +extern TBox *float_tstzspan_to_tbox(double d, const Span *s); +extern TBox *int_timestamptz_to_tbox(int i, TimestampTz t); +extern TBox *int_tstzspan_to_tbox(int i, const Span *s); +extern TBox *numspan_tstzspan_to_tbox(const Span *span, const Span *s); +extern TBox *numspan_timestamptz_to_tbox(const Span *span, TimestampTz t); +extern TBox *tbox_copy(const TBox *box); +extern TBox *tbox_make(const Span *s, const Span *p); + +/***************************************************************************** + * Conversion functions for box types + *****************************************************************************/ + +extern TBox *float_to_tbox(double d); +extern TBox *int_to_tbox(int i); +extern TBox *set_to_tbox(const Set *s); +extern TBox *span_to_tbox(const Span *s); +extern TBox *spanset_to_tbox(const SpanSet *ss); +extern Span *tbox_to_bigintspan(const TBox *box); +extern Span *tbox_to_intspan(const TBox *box); +extern Span *tbox_to_floatspan(const TBox *box); +extern Span *tbox_to_tstzspan(const TBox *box); +extern TBox *timestamptz_to_tbox(TimestampTz t); + +/***************************************************************************** + * Accessor functions for box types + *****************************************************************************/ + +extern uint32 tbox_hash(const TBox *box); +extern uint64 tbox_hash_extended(const TBox *box, uint64 seed); +extern bool tbox_hast(const TBox *box); +extern bool tbox_hasx(const TBox *box); +extern bool tbox_tmax(const TBox *box, TimestampTz *result); +extern bool tbox_tmax_inc(const TBox *box, bool *result); +extern bool tbox_tmin(const TBox *box, TimestampTz *result); +extern bool tbox_tmin_inc(const TBox *box, bool *result); +extern bool tbox_xmax(const TBox *box, double *result); +extern bool tbox_xmax_inc(const TBox *box, bool *result); +extern bool tbox_xmin(const TBox *box, double *result); +extern bool tbox_xmin_inc(const TBox *box, bool *result); +extern bool tboxfloat_xmax(const TBox *box, double *result); +extern bool tboxfloat_xmin(const TBox *box, double *result); +extern bool tboxint_xmax(const TBox *box, int *result); +extern bool tboxint_xmin(const TBox *box, int *result); + +/***************************************************************************** + * Transformation functions for box types + *****************************************************************************/ + +extern TBox *tbigintbox_expand(const TBox *box, int64 i); +extern TBox *tbigintbox_shift_scale(const TBox *box, int64 shift, int64 width, bool hasshift, bool haswidth); +extern TBox *tbox_expand_time(const TBox *box, const Interval *interv); +extern TBox *tbox_round(const TBox *box, int maxdd); +extern TBox *tbox_shift_scale_time(const TBox *box, const Interval *shift, const Interval *duration); +extern TBox *tfloatbox_expand(const TBox *box, double d); +extern TBox *tfloatbox_shift_scale(const TBox *box, double shift, double width, bool hasshift, bool haswidth); +extern TBox *tintbox_expand(const TBox *box, int i); +extern TBox *tintbox_shift_scale(const TBox *box, int shift, int width, bool hasshift, bool haswidth); + +/***************************************************************************** + * Set functions for box types + *****************************************************************************/ + +extern TBox *union_tbox_tbox(const TBox *box1, const TBox *box2, bool strict); +extern TBox *intersection_tbox_tbox(const TBox *box1, const TBox *box2); + +/***************************************************************************** + * Bounding box functions for box types + *****************************************************************************/ + +/* Topological functions for box types */ + +extern bool adjacent_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool contained_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool contains_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overlaps_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool same_tbox_tbox(const TBox *box1, const TBox *box2); + +/*****************************************************************************/ + +/* Position functions for box types */ + +extern bool after_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool before_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool left_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overafter_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overbefore_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overleft_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool overright_tbox_tbox(const TBox *box1, const TBox *box2); +extern bool right_tbox_tbox(const TBox *box1, const TBox *box2); + +/***************************************************************************** + * Comparison functions for box types + *****************************************************************************/ + +extern int tbox_cmp(const TBox *box1, const TBox *box2); +extern bool tbox_eq(const TBox *box1, const TBox *box2); +extern bool tbox_ge(const TBox *box1, const TBox *box2); +extern bool tbox_gt(const TBox *box1, const TBox *box2); +extern bool tbox_le(const TBox *box1, const TBox *box2); +extern bool tbox_lt(const TBox *box1, const TBox *box2); +extern bool tbox_ne(const TBox *box1, const TBox *box2); + +/*===========================================================================* + * Functions for temporal types + *===========================================================================*/ + +/***************************************************************************** + * Input and output functions for temporal types + *****************************************************************************/ + +extern Temporal *tbigint_from_mfjson(const char *str); +extern Temporal *tbigint_in(const char *str); +extern char *tbigint_out(const Temporal *temp); +extern Temporal *tbool_from_mfjson(const char *str); +extern Temporal *tbool_in(const char *str); +extern char *tbool_out(const Temporal *temp); +extern char *temporal_as_hexwkb(const Temporal *temp, uint8_t variant, size_t *size_out); +extern char *temporal_as_mfjson(const Temporal *temp, bool with_bbox, int flags, int precision, const char *srs); +extern uint8_t *temporal_as_wkb(const Temporal *temp, uint8_t variant, size_t *size_out); +extern Temporal *temporal_from_hexwkb(const char *hexwkb); +extern Temporal *temporal_from_wkb(const uint8_t *wkb, size_t size); +extern Temporal *tfloat_from_mfjson(const char *str); +extern Temporal *tfloat_in(const char *str); +extern char *tfloat_out(const Temporal *temp, int maxdd); +extern Temporal *tint_from_mfjson(const char *str); +extern Temporal *tint_in(const char *str); +extern char *tint_out(const Temporal *temp); +extern Temporal *ttext_from_mfjson(const char *str); +extern Temporal *ttext_in(const char *str); +extern char *ttext_out(const Temporal *temp); + +/***************************************************************************** + * Constructor functions for temporal types + *****************************************************************************/ + +extern Temporal *tbigint_from_base_temp(int64 i, const Temporal *temp); +extern TInstant *tbigintinst_make(int64 i, TimestampTz t); +extern TSequence *tbigintseq_from_base_tstzset(int64 i, const Set *s); +extern TSequence *tbigintseq_from_base_tstzspan(int64 i, const Span *s); +extern TSequenceSet *tbigintseqset_from_base_tstzspanset(int64 i, const SpanSet *ss); +extern Temporal *tbool_from_base_temp(bool b, const Temporal *temp); +extern TInstant *tboolinst_make(bool b, TimestampTz t); +extern TSequence *tboolseq_from_base_tstzset(bool b, const Set *s); +extern TSequence *tboolseq_from_base_tstzspan(bool b, const Span *s); +extern TSequenceSet *tboolseqset_from_base_tstzspanset(bool b, const SpanSet *ss); +extern Temporal *temporal_copy(const Temporal *temp); +extern Temporal *tfloat_from_base_temp(double d, const Temporal *temp); +extern TInstant *tfloatinst_make(double d, TimestampTz t); +extern TSequence *tfloatseq_from_base_tstzset(double d, const Set *s); +extern TSequence *tfloatseq_from_base_tstzspan(double d, const Span *s, interpType interp); +extern TSequenceSet *tfloatseqset_from_base_tstzspanset(double d, const SpanSet *ss, interpType interp); +extern Temporal *tint_from_base_temp(int i, const Temporal *temp); +extern TInstant *tintinst_make(int i, TimestampTz t); +extern TSequence *tintseq_from_base_tstzset(int i, const Set *s); +extern TSequence *tintseq_from_base_tstzspan(int i, const Span *s); +extern TSequenceSet *tintseqset_from_base_tstzspanset(int i, const SpanSet *ss); +extern TSequence *tsequence_make(TInstant **instants, int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequenceSet *tsequenceset_make(TSequence **sequences, int count, bool normalize); +extern TSequenceSet *tsequenceset_make_gaps(TInstant **instants, int count, interpType interp, const Interval *maxt, double maxdist); +extern Temporal *ttext_from_base_temp(const text *txt, const Temporal *temp); +extern TInstant *ttextinst_make(const text *txt, TimestampTz t); +extern TSequence *ttextseq_from_base_tstzset(const text *txt, const Set *s); +extern TSequence *ttextseq_from_base_tstzspan(const text *txt, const Span *s); +extern TSequenceSet *ttextseqset_from_base_tstzspanset(const text *txt, const SpanSet *ss); + +/***************************************************************************** + * Conversion functions for temporal types + *****************************************************************************/ + +extern Temporal *tbigint_to_tfloat(const Temporal *temp); +extern Temporal *tbigint_to_tint(const Temporal *temp); +extern Temporal *tbool_to_tint(const Temporal *temp); +extern Span *temporal_to_tstzspan(const Temporal *temp); +extern Temporal *tfloat_to_tbigint(const Temporal *temp); +extern Temporal *tfloat_to_tint(const Temporal *temp); +extern Temporal *tint_to_tbigint(const Temporal *temp); +extern Temporal *tint_to_tfloat(const Temporal *temp); +extern Span *tnumber_to_span(const Temporal *temp); +extern TBox *tnumber_to_tbox (const Temporal *temp); + +/***************************************************************************** + * Accessor functions for temporal types + *****************************************************************************/ + +extern int64 tbigint_end_value(const Temporal *temp); +extern int64 tbigint_max_value(const Temporal *temp); +extern int64 tbigint_min_value(const Temporal *temp); +extern int64 tbigint_start_value(const Temporal *temp); +extern bool tbigint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, int64 *value); +extern bool tbigint_value_n(const Temporal *temp, int64 n, int64 *result); +extern int64 *tbigint_values(const Temporal *temp, int32 *count); +extern bool tbool_end_value(const Temporal *temp); +extern bool tbool_start_value(const Temporal *temp); +extern bool tbool_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, bool *value); +extern bool tbool_value_n(const Temporal *temp, int n, bool *result); +extern bool *tbool_values(const Temporal *temp, int *count); +extern Interval *temporal_duration(const Temporal *temp, bool boundspan); +extern TInstant *temporal_end_instant(const Temporal *temp); +extern TSequence *temporal_end_sequence(const Temporal *temp); +extern TimestampTz temporal_end_timestamptz(const Temporal *temp); +extern uint32 temporal_hash(const Temporal *temp); +extern TInstant *temporal_instant_n(const Temporal *temp, int n); +extern TInstant **temporal_instants(const Temporal *temp, int *count); +extern const char *temporal_interp(const Temporal *temp); +extern bool temporal_lower_inc(const Temporal *temp); +extern TInstant *temporal_max_instant(const Temporal *temp); +extern TInstant *temporal_min_instant(const Temporal *temp); +extern int temporal_num_instants(const Temporal *temp); +extern int temporal_num_sequences(const Temporal *temp); +extern int temporal_num_timestamps(const Temporal *temp); +extern TSequenceSet *temporal_segm_duration(const Temporal *temp, const Interval *duration, bool atleast, bool strict); +extern TSequence **temporal_segments(const Temporal *temp, int *count); +extern TSequence *temporal_sequence_n(const Temporal *temp, int i); +extern TSequence **temporal_sequences(const Temporal *temp, int *count); +extern TInstant *temporal_start_instant(const Temporal *temp); +extern TSequence *temporal_start_sequence(const Temporal *temp); +extern TimestampTz temporal_start_timestamptz(const Temporal *temp); +extern TSequenceSet *temporal_stops(const Temporal *temp, double maxdist, const Interval *minduration); +extern const char *temporal_subtype(const Temporal *temp); +extern SpanSet *temporal_time(const Temporal *temp); +extern TimestampTz *temporal_timestamps(const Temporal *temp, int *count); +extern bool temporal_timestamptz_n(const Temporal *temp, int n, TimestampTz *result); +extern bool temporal_upper_inc(const Temporal *temp); +extern double tfloat_avg_value(const Temporal *temp); +extern double tfloat_end_value(const Temporal *temp); +extern double tfloat_min_value(const Temporal *temp); +extern double tfloat_max_value(const Temporal *temp); +extern double tfloat_start_value(const Temporal *temp); +extern bool tfloat_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, double *value); +extern bool tfloat_value_n(const Temporal *temp, int n, double *result); +extern double *tfloat_values(const Temporal *temp, int *count); +extern int tint_end_value(const Temporal *temp); +extern int tint_max_value(const Temporal *temp); +extern int tint_min_value(const Temporal *temp); +extern int tint_start_value(const Temporal *temp); +extern bool tint_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, int *value); +extern bool tint_value_n(const Temporal *temp, int n, int *result); +extern int *tint_values(const Temporal *temp, int *count); +extern double tnumber_avg_value(const Temporal *temp); +extern double tnumber_integral(const Temporal *temp); +extern double tnumber_twavg(const Temporal *temp); +extern SpanSet *tnumber_valuespans(const Temporal *temp); +extern text *ttext_end_value(const Temporal *temp); +extern text *ttext_max_value(const Temporal *temp); +extern text *ttext_min_value(const Temporal *temp); +extern text *ttext_start_value(const Temporal *temp); +extern bool ttext_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, text **value); +extern bool ttext_value_n(const Temporal *temp, int n, text **result); +extern text **ttext_values(const Temporal *temp, int *count); + +/***************************************************************************** + * Transformation functions for temporal types + *****************************************************************************/ + +extern double float_degrees(double value, bool normalize); +extern Temporal *tbigint_scale_value(const Temporal *temp, int64 width); +extern Temporal *tbigint_shift_scale_value(const Temporal *temp, int64 shift, int64 width); +extern Temporal *tbigint_shift_value(const Temporal *temp, int64 shift); +extern Temporal **temparr_round(Temporal **temp, int count, int maxdd); +extern Temporal *temporal_round(const Temporal *temp, int maxdd); +extern Temporal *temporal_scale_time(const Temporal *temp, const Interval *duration); +extern Temporal *temporal_set_interp(const Temporal *temp, interpType interp); +extern Temporal *temporal_shift_scale_time(const Temporal *temp, const Interval *shift, const Interval *duration); +extern Temporal *temporal_shift_time(const Temporal *temp, const Interval *shift); +extern TInstant *temporal_to_tinstant(const Temporal *temp); +extern TSequence *temporal_to_tsequence(const Temporal *temp, interpType interp); +extern TSequenceSet *temporal_to_tsequenceset(const Temporal *temp, interpType interp); +extern Temporal *tfloat_ceil(const Temporal *temp); +extern Temporal *tfloat_degrees(const Temporal *temp, bool normalize); +extern Temporal *tfloat_floor(const Temporal *temp); +extern Temporal *tfloat_radians(const Temporal *temp); +extern Temporal *tfloat_scale_value(const Temporal *temp, double width); +extern Temporal *tfloat_shift_scale_value(const Temporal *temp, double shift, double width); +extern Temporal *tfloat_shift_value(const Temporal *temp, double shift); +extern Temporal *tint_scale_value(const Temporal *temp, int width); +extern Temporal *tint_shift_scale_value(const Temporal *temp, int shift, int width); +extern Temporal *tint_shift_value(const Temporal *temp, int shift); + +/***************************************************************************** + * Modification functions for temporal types + *****************************************************************************/ + +extern Temporal *temporal_append_tinstant(Temporal *temp, const TInstant *inst, interpType interp, double maxdist, const Interval *maxt, bool expand); +extern Temporal *temporal_append_tsequence(Temporal *temp, const TSequence *seq, bool expand); +extern Temporal *temporal_delete_timestamptz(const Temporal *temp, TimestampTz t, bool connect); +extern Temporal *temporal_delete_tstzset(const Temporal *temp, const Set *s, bool connect); +extern Temporal *temporal_delete_tstzspan(const Temporal *temp, const Span *s, bool connect); +extern Temporal *temporal_delete_tstzspanset(const Temporal *temp, const SpanSet *ss, bool connect); +extern Temporal *temporal_insert(const Temporal *temp1, const Temporal *temp2, bool connect); +extern Temporal *temporal_merge(const Temporal *temp1, const Temporal *temp2); +extern Temporal *temporal_merge_array(Temporal **temparr, int count); +extern Temporal *temporal_update(const Temporal *temp1, const Temporal *temp2, bool connect); + +/***************************************************************************** + * Restriction functions for temporal types + *****************************************************************************/ + +extern Temporal *tbigint_at_value(const Temporal *temp, int64 i); +extern Temporal *tbigint_minus_value(const Temporal *temp, int64 i); +extern Temporal *tbool_at_value(const Temporal *temp, bool b); +extern Temporal *tbool_minus_value(const Temporal *temp, bool b); +extern Temporal *temporal_after_timestamptz(const Temporal *temp, TimestampTz t, bool strict); +extern Temporal *temporal_at_max(const Temporal *temp); +extern Temporal *temporal_at_min(const Temporal *temp); +extern Temporal *temporal_at_timestamptz(const Temporal *temp, TimestampTz t); +extern Temporal *temporal_at_tstzset(const Temporal *temp, const Set *s); +extern Temporal *temporal_at_tstzspan(const Temporal *temp, const Span *s); +extern Temporal *temporal_at_tstzspanset(const Temporal *temp, const SpanSet *ss); +extern Temporal *temporal_at_values(const Temporal *temp, const Set *set); +extern Temporal *temporal_before_timestamptz(const Temporal *temp, TimestampTz t, bool strict); +extern Temporal *temporal_minus_max(const Temporal *temp); +extern Temporal *temporal_minus_min(const Temporal *temp); +extern Temporal *temporal_minus_timestamptz(const Temporal *temp, TimestampTz t); +extern Temporal *temporal_minus_tstzset(const Temporal *temp, const Set *s); +extern Temporal *temporal_minus_tstzspan(const Temporal *temp, const Span *s); +extern Temporal *temporal_minus_tstzspanset(const Temporal *temp, const SpanSet *ss); +extern Temporal *temporal_minus_values(const Temporal *temp, const Set *set); +extern Temporal *tfloat_at_value(const Temporal *temp, double d); +extern Temporal *tfloat_minus_value(const Temporal *temp, double d); +extern Temporal *tint_at_value(const Temporal *temp, int i); +extern Temporal *tint_minus_value(const Temporal *temp, int i); +extern Temporal *tnumber_at_span(const Temporal *temp, const Span *span); +extern Temporal *tnumber_at_spanset(const Temporal *temp, const SpanSet *ss); +extern Temporal *tnumber_at_tbox(const Temporal *temp, const TBox *box); +extern Temporal *tnumber_minus_span(const Temporal *temp, const Span *span); +extern Temporal *tnumber_minus_spanset(const Temporal *temp, const SpanSet *ss); +extern Temporal *tnumber_minus_tbox(const Temporal *temp, const TBox *box); +extern Temporal *ttext_at_value(const Temporal *temp, text *txt); +extern Temporal *ttext_minus_value(const Temporal *temp, text *txt); + +/***************************************************************************** + * Comparison functions for temporal types + *****************************************************************************/ + +/* Traditional comparison functions for temporal types */ + +extern int temporal_cmp(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_eq(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_ge(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_gt(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_le(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_lt(const Temporal *temp1, const Temporal *temp2); +extern bool temporal_ne(const Temporal *temp1, const Temporal *temp2); + +/*****************************************************************************/ + +/* Ever and always comparison functions for temporal types */ + +extern int always_eq_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_eq_bool_tbool(bool b, const Temporal *temp); +extern int always_eq_float_tfloat(double d, const Temporal *temp); +extern int always_eq_int_tint(int i, const Temporal *temp); +extern int always_eq_tbool_bool(const Temporal *temp, bool b); +extern int always_eq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_eq_text_ttext(const text *txt, const Temporal *temp); +extern int always_eq_tbigint_bigint(const Temporal *temp, int64 i); +extern int always_eq_tfloat_float(const Temporal *temp, double d); +extern int always_eq_tint_int(const Temporal *temp, int i); +extern int always_eq_ttext_text(const Temporal *temp, const text *txt); + +extern int always_ge_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_ge_float_tfloat(double d, const Temporal *temp); +extern int always_ge_int_tint(int i, const Temporal *temp); +extern int always_ge_tbigint_bigint(const Temporal *temp, int64 i); +extern int always_ge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_ge_text_ttext(const text *txt, const Temporal *temp); +extern int always_ge_tfloat_float(const Temporal *temp, double d); +extern int always_ge_tint_int(const Temporal *temp, int i); +extern int always_ge_ttext_text(const Temporal *temp, const text *txt); + +extern int always_gt_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_gt_float_tfloat(double d, const Temporal *temp); +extern int always_gt_int_tint(int i, const Temporal *temp); +extern int always_gt_tbigint_bigint(const Temporal *temp, int64 i); +extern int always_gt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_gt_text_ttext(const text *txt, const Temporal *temp); +extern int always_gt_tfloat_float(const Temporal *temp, double d); +extern int always_gt_tint_int(const Temporal *temp, int i); +extern int always_gt_ttext_text(const Temporal *temp, const text *txt); + +extern int always_le_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_le_float_tfloat(double d, const Temporal *temp); +extern int always_le_int_tint(int i, const Temporal *temp); +extern int always_le_tbigint_bigint(const Temporal *temp, int64 i); +extern int always_le_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_le_text_ttext(const text *txt, const Temporal *temp); +extern int always_le_tfloat_float(const Temporal *temp, double d); +extern int always_le_tint_int(const Temporal *temp, int i); +extern int always_le_ttext_text(const Temporal *temp, const text *txt); + +extern int always_lt_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_lt_float_tfloat(double d, const Temporal *temp); +extern int always_lt_int_tint(int i, const Temporal *temp); +extern int always_lt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_lt_text_ttext(const text *txt, const Temporal *temp); +extern int always_lt_tfloat_float(const Temporal *temp, double d); +extern int always_lt_tint_int(const Temporal *temp, int i); +extern int always_lt_ttext_text(const Temporal *temp, const text *txt); +extern int always_ne_bool_tbool(bool b, const Temporal *temp); +extern int always_ne_float_tfloat(double d, const Temporal *temp); +extern int always_ne_int_tint(int i, const Temporal *temp); +extern int always_lt_tbigint_bigint(const Temporal *temp, int64 i); + +extern int always_ne_bigint_tbigint(int64 i, const Temporal *temp); +extern int always_ne_tbool_bool(const Temporal *temp, bool b); +extern int always_ne_tbigint_bigint(const Temporal *temp, int64 i); +extern int always_ne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_text_ttext(const text *txt, const Temporal *temp); +extern int always_ne_tfloat_float(const Temporal *temp, double d); +extern int always_ne_tint_int(const Temporal *temp, int i); +extern int always_ne_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_eq_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_eq_bool_tbool(bool b, const Temporal *temp); +extern int ever_eq_float_tfloat(double d, const Temporal *temp); +extern int ever_eq_int_tint(int i, const Temporal *temp); +extern int ever_eq_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_eq_tbool_bool(const Temporal *temp, bool b); +extern int ever_eq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_text_ttext(const text *txt, const Temporal *temp); +extern int ever_eq_tfloat_float(const Temporal *temp, double d); +extern int ever_eq_tint_int(const Temporal *temp, int i); +extern int ever_eq_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_ge_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_ge_float_tfloat(double d, const Temporal *temp); +extern int ever_ge_int_tint(int i, const Temporal *temp); +extern int ever_ge_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_ge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_ge_text_ttext(const text *txt, const Temporal *temp); +extern int ever_ge_tfloat_float(const Temporal *temp, double d); +extern int ever_ge_tint_int(const Temporal *temp, int i); +extern int ever_ge_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_gt_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_gt_float_tfloat(double d, const Temporal *temp); +extern int ever_gt_int_tint(int i, const Temporal *temp); +extern int ever_gt_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_gt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_gt_text_ttext(const text *txt, const Temporal *temp); +extern int ever_gt_tfloat_float(const Temporal *temp, double d); +extern int ever_gt_tint_int(const Temporal *temp, int i); +extern int ever_gt_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_le_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_le_float_tfloat(double d, const Temporal *temp); +extern int ever_le_int_tint(int i, const Temporal *temp); +extern int ever_le_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_le_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_le_text_ttext(const text *txt, const Temporal *temp); +extern int ever_le_tfloat_float(const Temporal *temp, double d); +extern int ever_le_tint_int(const Temporal *temp, int i); +extern int ever_le_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_lt_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_lt_float_tfloat(double d, const Temporal *temp); +extern int ever_lt_int_tint(int i, const Temporal *temp); +extern int ever_lt_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_lt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_lt_text_ttext(const text *txt, const Temporal *temp); +extern int ever_lt_tfloat_float(const Temporal *temp, double d); +extern int ever_lt_tint_int(const Temporal *temp, int i); +extern int ever_lt_ttext_text(const Temporal *temp, const text *txt); + +extern int ever_ne_bigint_tbigint(int64 i, const Temporal *temp); +extern int ever_ne_bool_tbool(bool b, const Temporal *temp); +extern int ever_ne_float_tfloat(double d, const Temporal *temp); +extern int ever_ne_int_tint(int i, const Temporal *temp); +extern int ever_ne_tbigint_bigint(const Temporal *temp, int64 i); +extern int ever_ne_tbool_bool(const Temporal *temp, bool b); +extern int ever_ne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_text_ttext(const text *txt, const Temporal *temp); +extern int ever_ne_tfloat_float(const Temporal *temp, double d); +extern int ever_ne_tint_int(const Temporal *temp, int i); +extern int ever_ne_ttext_text(const Temporal *temp, const text *txt); + +/*****************************************************************************/ + +/* Temporal comparison functions for temporal types */ + +extern Temporal *teq_bool_tbool(bool b, const Temporal *temp); +extern Temporal *teq_float_tfloat(double d, const Temporal *temp); +extern Temporal *teq_int_tint(int i, const Temporal *temp); +extern Temporal *teq_tbool_bool(const Temporal *temp, bool b); +extern Temporal *teq_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *teq_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *teq_tfloat_float(const Temporal *temp, double d); +extern Temporal *teq_tint_int(const Temporal *temp, int i); +extern Temporal *teq_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tge_float_tfloat(double d, const Temporal *temp); +extern Temporal *tge_int_tint(int i, const Temporal *temp); +extern Temporal *tge_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tge_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *tge_tfloat_float(const Temporal *temp, double d); +extern Temporal *tge_tint_int(const Temporal *temp, int i); +extern Temporal *tge_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tgt_float_tfloat(double d, const Temporal *temp); +extern Temporal *tgt_int_tint(int i, const Temporal *temp); +extern Temporal *tgt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tgt_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *tgt_tfloat_float(const Temporal *temp, double d); +extern Temporal *tgt_tint_int(const Temporal *temp, int i); +extern Temporal *tgt_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tle_float_tfloat(double d, const Temporal *temp); +extern Temporal *tle_int_tint(int i, const Temporal *temp); +extern Temporal *tle_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tle_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *tle_tfloat_float(const Temporal *temp, double d); +extern Temporal *tle_tint_int(const Temporal *temp, int i); +extern Temporal *tle_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tlt_float_tfloat(double d, const Temporal *temp); +extern Temporal *tlt_int_tint(int i, const Temporal *temp); +extern Temporal *tlt_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tlt_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *tlt_tfloat_float(const Temporal *temp, double d); +extern Temporal *tlt_tint_int(const Temporal *temp, int i); +extern Temporal *tlt_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *tne_bool_tbool(bool b, const Temporal *temp); +extern Temporal *tne_float_tfloat(double d, const Temporal *temp); +extern Temporal *tne_int_tint(int i, const Temporal *temp); +extern Temporal *tne_tbool_bool(const Temporal *temp, bool b); +extern Temporal *tne_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tne_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *tne_tfloat_float(const Temporal *temp, double d); +extern Temporal *tne_tint_int(const Temporal *temp, int i); +extern Temporal *tne_ttext_text(const Temporal *temp, const text *txt); + +/***************************************************************************** + * Bounding box functions for temporal types + *****************************************************************************/ + +/* Split functions */ + +extern Span *temporal_spans(const Temporal *temp, int *count); +extern Span *temporal_split_each_n_spans(const Temporal *temp, int elem_count, int *count); +extern Span *temporal_split_n_spans(const Temporal *temp, int span_count, int *count); +extern TBox *tnumber_split_each_n_tboxes(const Temporal *temp, int elem_count, int *count); +extern TBox *tnumber_split_n_tboxes(const Temporal *temp, int box_count, int *count); +extern TBox *tnumber_tboxes(const Temporal *temp, int *count); + +/* Topological functions for temporal types */ + +extern bool adjacent_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool adjacent_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool adjacent_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool adjacent_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool adjacent_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool adjacent_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool adjacent_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool adjacent_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool contained_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool contained_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool contained_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool contained_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool contained_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool contained_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool contained_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool contained_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool contains_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool contains_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool contains_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool contains_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool contains_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool contains_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool contains_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool contains_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool overlaps_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool overlaps_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool overlaps_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool overlaps_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool overlaps_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool overlaps_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool overlaps_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool overlaps_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool same_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool same_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool same_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool same_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool same_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool same_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool same_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool same_tstzspan_temporal(const Span *s, const Temporal *temp); + +/*****************************************************************************/ + +/* Position functions for temporal types */ + +extern bool after_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool after_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool after_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool after_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool after_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool after_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool before_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool before_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool before_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool before_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool before_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool before_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool left_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool left_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool left_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool left_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool left_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool overafter_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool overafter_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool overafter_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool overafter_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool overafter_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool overafter_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool overbefore_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool overbefore_temporal_tstzspan(const Temporal *temp, const Span *s); +extern bool overbefore_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool overbefore_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool overbefore_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool overbefore_tstzspan_temporal(const Span *s, const Temporal *temp); +extern bool overleft_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool overleft_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool overleft_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool overleft_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool overleft_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool overright_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool overright_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool overright_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool overright_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool overright_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool right_numspan_tnumber(const Span *s, const Temporal *temp); +extern bool right_tbox_tnumber(const TBox *box, const Temporal *temp); +extern bool right_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool right_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool right_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Boolean functions for temporal types + *****************************************************************************/ + +extern Temporal *tand_bool_tbool(bool b, const Temporal *temp); +extern Temporal *tand_tbool_bool(const Temporal *temp, bool b); +extern Temporal *tand_tbool_tbool(const Temporal *temp1, const Temporal *temp2); +extern SpanSet *tbool_when_true(const Temporal *temp); +extern Temporal *tnot_tbool(const Temporal *temp); +extern Temporal *tor_bool_tbool(bool b, const Temporal *temp); +extern Temporal *tor_tbool_bool(const Temporal *temp, bool b); +extern Temporal *tor_tbool_tbool(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Mathematical functions for temporal types + *****************************************************************************/ + +extern Temporal *add_bigint_tbigint(int64 i, const Temporal *tnumber); +extern Temporal *add_float_tfloat(double d, const Temporal *tnumber); +extern Temporal *add_int_tint(int i, const Temporal *tnumber); +extern Temporal *add_tbigint_bigint(const Temporal *tnumber, int64 i); +extern Temporal *add_tfloat_float(const Temporal *tnumber, double d); +extern Temporal *add_tint_int(const Temporal *tnumber, int i); +extern Temporal *add_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); +extern Temporal *div_bigint_tbigint(int64 i, const Temporal *tnumber); +extern Temporal *div_float_tfloat(double d, const Temporal *tnumber); +extern Temporal *div_int_tint(int i, const Temporal *tnumber); +extern Temporal *div_tbigint_bigint(const Temporal *tnumber, int64 i); +extern Temporal *div_tfloat_float(const Temporal *tnumber, double d); +extern Temporal *div_tint_int(const Temporal *tnumber, int i); +extern Temporal *div_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); +extern Temporal *mul_bigint_tbigint(int64 i, const Temporal *tnumber); +extern Temporal *mul_float_tfloat(double d, const Temporal *tnumber); +extern Temporal *mul_int_tint(int i, const Temporal *tnumber); +extern Temporal *mul_tbigint_bigint(const Temporal *tnumber, int64 i); +extern Temporal *mul_tfloat_float(const Temporal *tnumber, double d); +extern Temporal *mul_tint_int(const Temporal *tnumber, int i); +extern Temporal *mul_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); +extern Temporal *sub_bigint_tbigint(int64 i, const Temporal *tnumber); +extern Temporal *sub_float_tfloat(double d, const Temporal *tnumber); +extern Temporal *sub_int_tint(int i, const Temporal *tnumber); +extern Temporal *sub_tbigint_bigint(const Temporal *tnumber, int64 i); +extern Temporal *sub_tfloat_float(const Temporal *tnumber, double d); +extern Temporal *sub_tint_int(const Temporal *tnumber, int i); +extern Temporal *sub_tnumber_tnumber(const Temporal *tnumber1, const Temporal *tnumber2); +extern Temporal *temporal_derivative(const Temporal *temp); +extern Temporal *tfloat_exp(const Temporal *temp); +extern Temporal *tfloat_ln(const Temporal *temp); +extern Temporal *tfloat_log10(const Temporal *temp); +extern Temporal *tnumber_abs(const Temporal *temp); +extern Temporal *tnumber_trend(const Temporal *temp); +extern double float_angular_difference(double degrees1, double degrees2); +extern Temporal *tnumber_angular_difference(const Temporal *temp); +extern Temporal *tnumber_delta_value(const Temporal *temp); + +/***************************************************************************** + * Text functions for temporal types + *****************************************************************************/ + +extern Temporal *textcat_text_ttext(const text *txt, const Temporal *temp); +extern Temporal *textcat_ttext_text(const Temporal *temp, const text *txt); +extern Temporal *textcat_ttext_ttext(const Temporal *temp1, const Temporal *temp2); +extern Temporal *ttext_initcap(const Temporal *temp); +extern Temporal *ttext_upper(const Temporal *temp); +extern Temporal *ttext_lower(const Temporal *temp); + +/***************************************************************************** + * Distance functions for temporal types + *****************************************************************************/ + +extern Temporal *tdistance_tfloat_float(const Temporal *temp, double d); +extern Temporal *tdistance_tint_int(const Temporal *temp, int i); +extern Temporal *tdistance_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern double nad_tboxfloat_tboxfloat(const TBox *box1, const TBox *box2); +extern int nad_tboxint_tboxint(const TBox *box1, const TBox *box2); +extern double nad_tfloat_float(const Temporal *temp, double d); +extern double nad_tfloat_tfloat(const Temporal *temp1, const Temporal *temp2); +extern double nad_tfloat_tbox(const Temporal *temp, const TBox *box); +extern int nad_tint_int(const Temporal *temp, int i); +extern int nad_tint_tbox(const Temporal *temp, const TBox *box); +extern int nad_tint_tint(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Aggregate functions for temporal types + *****************************************************************************/ + +extern SkipList *tbool_tand_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tbool_tor_transfn(SkipList *state, const Temporal *temp); +extern Span *temporal_extent_transfn(Span *s, const Temporal *temp); +extern SkipList *temporal_merge_transfn(SkipList *state, const Temporal *temp); +extern SkipList *temporal_merge_combinefn(SkipList *state1, SkipList *state2); +extern Temporal *temporal_tagg_finalfn(SkipList *state); +extern SkipList *temporal_tcount_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tfloat_tmax_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tfloat_tmin_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tfloat_tsum_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tfloat_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tfloat_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tfloat_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *timestamptz_tcount_transfn(SkipList *state, TimestampTz t); +extern SkipList *tint_tmax_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tint_tmin_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tint_tsum_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tint_wmax_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tint_wmin_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tint_wsum_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern TBox *tnumber_extent_transfn(TBox *box, const Temporal *temp); +extern Temporal *tnumber_tavg_finalfn(SkipList *state); +extern SkipList *tnumber_tavg_transfn(SkipList *state, const Temporal *temp); +extern SkipList *tnumber_wavg_transfn(SkipList *state, const Temporal *temp, const Interval *interv); +extern SkipList *tstzset_tcount_transfn(SkipList *state, const Set *s); +extern SkipList *tstzspan_tcount_transfn(SkipList *state, const Span *s); +extern SkipList *tstzspanset_tcount_transfn(SkipList *state, const SpanSet *ss); +extern SkipList *ttext_tmax_transfn(SkipList *state, const Temporal *temp); +extern SkipList *ttext_tmin_transfn(SkipList *state, const Temporal *temp); + +/***************************************************************************** + * Analytics functions for temporal types + *****************************************************************************/ + +/* Simplification functions for temporal types */ + +extern Temporal *temporal_simplify_dp(const Temporal *temp, double eps_dist, bool synchronized); +extern Temporal *temporal_simplify_max_dist(const Temporal *temp, double eps_dist, bool synchronized); +extern Temporal *temporal_simplify_min_dist(const Temporal *temp, double dist); +extern Temporal *temporal_simplify_min_tdelta(const Temporal *temp, const Interval *mint); + +/*****************************************************************************/ + +/* Reduction functions for temporal types */ + +extern Temporal *temporal_tprecision(const Temporal *temp, const Interval *duration, TimestampTz origin); +extern Temporal *temporal_tsample(const Temporal *temp, const Interval *duration, TimestampTz origin, interpType interp); + +/*****************************************************************************/ + +/* Similarity functions for temporal types */ + +extern double temporal_dyntimewarp_distance(const Temporal *temp1, const Temporal *temp2); +extern Match *temporal_dyntimewarp_path(const Temporal *temp1, const Temporal *temp2, int *count); +extern double temporal_frechet_distance(const Temporal *temp1, const Temporal *temp2); +extern Match *temporal_frechet_path(const Temporal *temp1, const Temporal *temp2, int *count); +extern double temporal_hausdorff_distance(const Temporal *temp1, const Temporal *temp2); + +/*****************************************************************************/ + +/* Tile functions for temporal types */ + +extern Span *temporal_time_bins(const Temporal *temp, const Interval *duration, TimestampTz origin, int *count); +extern Temporal **temporal_time_split(const Temporal *temp, const Interval *duration, TimestampTz torigin, TimestampTz **time_bins, int *count); +extern TBox *tfloat_time_boxes(const Temporal *temp, const Interval *duration, TimestampTz torigin, int *count); +extern Span *tfloat_value_bins(const Temporal *temp, double vsize, double vorigin, int *count); +extern TBox *tfloat_value_boxes(const Temporal *temp, double vsize, double vorigin, int *count); +extern Temporal **tfloat_value_split(const Temporal *temp, double size, double origin, double **bins, int *count); +extern TBox *tfloat_value_time_boxes(const Temporal *temp, double vsize, const Interval *duration, double vorigin, TimestampTz torigin, int *count); +extern Temporal **tfloat_value_time_split(const Temporal *temp, double vsize, const Interval *duration, double vorigin, TimestampTz torigin, double **value_bins, TimestampTz **time_bins, int *count); +extern TBox *tfloatbox_time_tiles(const TBox *box, const Interval *duration, TimestampTz torigin, int *count); +extern TBox *tfloatbox_value_tiles(const TBox *box, double vsize, double vorigin, int *count); +extern TBox *tfloatbox_value_time_tiles(const TBox *box, double vsize, const Interval *duration, double vorigin, TimestampTz torigin, int *count); +extern TBox *tint_time_boxes(const Temporal *temp, const Interval *duration, TimestampTz torigin, int *count); +extern Span *tint_value_bins(const Temporal *temp, int vsize, int vorigin, int *count); +extern TBox *tint_value_boxes(const Temporal *temp, int vsize, int vorigin, int *count); +extern Temporal **tint_value_split(const Temporal *temp, int vsize, int vorigin, int **bins, int *count); +extern TBox *tint_value_time_boxes(const Temporal *temp, int vsize, const Interval *duration, int vorigin, TimestampTz torigin, int *count); +extern Temporal **tint_value_time_split(const Temporal *temp, int size, const Interval *duration, int vorigin, TimestampTz torigin, int **value_bins, TimestampTz **time_bins, int *count); +extern TBox *tintbox_time_tiles(const TBox *box, const Interval *duration, TimestampTz torigin, int *count); +extern TBox *tintbox_value_tiles(const TBox *box, int xsize, int xorigin, int *count); +extern TBox *tintbox_value_time_tiles(const TBox *box, int xsize, const Interval *duration, int xorigin, TimestampTz torigin, int *count); + +/*****************************************************************************/ + +extern void meos_initialize_noexit_error_handler(void); + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_cbuffer.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_cbuffer.h new file mode 100644 index 0000000..1d4b603 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_cbuffer.h @@ -0,0 +1,392 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief API of the Mobility Engine Open Source (MEOS) library. + */ + +#ifndef __MEOS_CBUFFER_H__ +#define __MEOS_CBUFFER_H__ + +/* C */ +#include +#include + +/* MEOS */ +#include +#include + +/***************************************************************************** + * Type definitions + *****************************************************************************/ + +/* Opaque structure to represent circular buffers */ + +typedef struct Cbuffer Cbuffer; + +/***************************************************************************** + * Validity macros and functions + *****************************************************************************/ + +/** + * @brief Macro for ensuring that the set passed as argument is a circular + * buffer set + */ +#if MEOS + #define VALIDATE_CBUFFERSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_CBUFFERSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_CBUFFERSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_CBUFFERSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value passed as argument is a + * temporal circular buffer + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TCBUFFER(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TCBUFFER) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TCBUFFER(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TCBUFFER); \ + } while (0) +#endif /* MEOS */ + +/****************************************************************************** + * Functions for circular buffers + ******************************************************************************/ + +/* Input and output functions */ + +extern char *cbuffer_as_ewkt(const Cbuffer *cb, int maxdd); +extern char *cbuffer_as_hexwkb(const Cbuffer *cb, uint8_t variant, size_t *size); +extern char *cbuffer_as_text(const Cbuffer *cb, int maxdd); +extern uint8_t *cbuffer_as_wkb(const Cbuffer *cb, uint8_t variant, size_t *size_out); +extern Cbuffer *cbuffer_from_hexwkb(const char *hexwkb); +extern Cbuffer *cbuffer_from_wkb(const uint8_t *wkb, size_t size); +extern Cbuffer *cbuffer_in(const char *str); +extern char *cbuffer_out(const Cbuffer *cb, int maxdd); + +/* Constructor functions */ + +extern Cbuffer *cbuffer_copy(const Cbuffer *cb); +extern Cbuffer *cbuffer_make(const GSERIALIZED *point, double radius); + +/* Conversion functions */ + +extern GSERIALIZED *cbuffer_to_geom(const Cbuffer *cb); +extern STBox *cbuffer_to_stbox(const Cbuffer *cb); +extern GSERIALIZED *cbufferarr_to_geom(const Cbuffer **cbarr, int count); +extern Cbuffer *geom_to_cbuffer(const GSERIALIZED *gs); + +/* Accessor functions */ + +extern uint32 cbuffer_hash(const Cbuffer *cb); +extern uint64 cbuffer_hash_extended(const Cbuffer *cb, uint64 seed); +extern GSERIALIZED *cbuffer_point(const Cbuffer *cb); +extern double cbuffer_radius(const Cbuffer *cb); + +/* Transformation functions */ + +extern Cbuffer *cbuffer_round(const Cbuffer *cb, int maxdd); +extern Cbuffer **cbufferarr_round(const Cbuffer **cbarr, int count, int maxdd); + +/* Spatial reference system functions */ + +extern void cbuffer_set_srid(Cbuffer *cb, int32_t srid); +extern int32_t cbuffer_srid(const Cbuffer *cb); +extern Cbuffer *cbuffer_transform(const Cbuffer *cb, int32_t srid); +extern Cbuffer *cbuffer_transform_pipeline(const Cbuffer *cb, const char *pipelinestr, int32_t srid, bool is_forward); + +/* Spatial relationship functions */ + +extern int contains_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int covers_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int disjoint_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int dwithin_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2, double dist); +extern int intersects_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern int touches_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); + +/* Bounding box functions */ + +extern STBox *cbuffer_tstzspan_to_stbox(const Cbuffer *cb, const Span *s); +extern STBox *cbuffer_timestamptz_to_stbox(const Cbuffer *cb, TimestampTz t); + +/* Distance functions */ + +extern double distance_cbuffer_cbuffer(const Cbuffer *cb1, const Cbuffer *cb2); +extern double distance_cbuffer_geo(const Cbuffer *cb, const GSERIALIZED *gs); +extern double distance_cbuffer_stbox(const Cbuffer *cb, const STBox *box); +extern double nad_cbuffer_stbox(const Cbuffer *cb, const STBox *box); + +/* Comparison functions */ + +extern int cbuffer_cmp(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_eq(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_ge(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_gt(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_le(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_lt(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_ne(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_nsame(const Cbuffer *cb1, const Cbuffer *cb2); +extern bool cbuffer_same(const Cbuffer *cb1, const Cbuffer *cb2); + +/****************************************************************************** + * Functions for circular buffer sets + ******************************************************************************/ + +/* Input and output functions */ + +extern Set *cbufferset_in(const char *str); +extern char *cbufferset_out(const Set *s, int maxdd); + +/* Constructor functions */ + +extern Set *cbufferset_make(Cbuffer **values, int count); + +/* Conversion functions */ + +extern Set *cbuffer_to_set(const Cbuffer *cb); + +/* Accessor functions */ + +extern Cbuffer *cbufferset_end_value(const Set *s); +extern Cbuffer *cbufferset_start_value(const Set *s); +extern bool cbufferset_value_n(const Set *s, int n, Cbuffer **result); +extern Cbuffer **cbufferset_values(const Set *s); + +/* Set operations */ + +extern Set *cbuffer_union_transfn(Set *state, const Cbuffer *cb); +extern bool contained_cbuffer_set(const Cbuffer *cb, const Set *s); +extern bool contains_set_cbuffer(const Set *s, Cbuffer *cb); +extern Set *intersection_cbuffer_set(const Cbuffer *cb, const Set *s); +extern Set *intersection_set_cbuffer(const Set *s, const Cbuffer *cb); +extern Set *minus_cbuffer_set(const Cbuffer *cb, const Set *s); +extern Set *minus_set_cbuffer(const Set *s, const Cbuffer *cb); +extern Set *union_cbuffer_set(const Cbuffer *cb, const Set *s); +extern Set *union_set_cbuffer(const Set *s, const Cbuffer *cb); + +/*===========================================================================* + * Functions for temporal types + *===========================================================================*/ + +/***************************************************************************** + * Input/output functions + *****************************************************************************/ + +extern Temporal *tcbuffer_in(const char *str); +extern Temporal *tcbuffer_from_mfjson(const char *mfjson); + +/***************************************************************************** + * Constructor functions + *****************************************************************************/ + +extern Temporal *tcbuffer_make(const Temporal *tpoint, const Temporal *tfloat); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +extern Set *tcbuffer_points(const Temporal *temp); +extern Set *tcbuffer_radius(const Temporal *temp); +extern GSERIALIZED *tcbuffer_trav_area(const Temporal *temp, bool merge_union); + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +extern Temporal *tcbuffer_to_tfloat(const Temporal *temp); +extern Temporal *tcbuffer_to_tgeompoint(const Temporal *temp); +extern Temporal *tgeometry_to_tcbuffer(const Temporal *temp); + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +extern Temporal *tcbuffer_expand(const Temporal *temp, double dist); + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +extern Temporal *tcbuffer_at_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tcbuffer_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcbuffer_at_stbox(const Temporal *temp, const STBox *box, bool border_inc); +extern Temporal *tcbuffer_minus_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tcbuffer_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcbuffer_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +extern Temporal *tdistance_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tdistance_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdistance_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern double nad_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern double nad_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern double nad_tcbuffer_stbox(const Temporal *temp, const STBox *box); +extern double nad_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern TInstant *nai_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern TInstant *nai_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern GSERIALIZED *shortestline_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Comparison functions + *****************************************************************************/ + +/* Ever/always comparison functions */ + +extern int always_eq_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int always_eq_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int always_eq_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int always_ne_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int always_ne_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int ever_eq_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int ever_eq_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int ever_ne_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int ever_ne_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); + +/* Temporal comparison functions */ + +extern Temporal *teq_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *teq_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tne_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *tne_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); + +/***************************************************************************** + * Spatial relationship functions + *****************************************************************************/ + +/* Ever and always spatial relationship functions */ + +extern int acontains_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int acontains_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern int acontains_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int acontains_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int acovers_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int acovers_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern int acovers_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int acovers_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int adisjoint_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int adisjoint_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int adisjoint_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int adwithin_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern int adwithin_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb, double dist); +extern int adwithin_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2, double dist); +extern int aintersects_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int aintersects_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int aintersects_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int atouches_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int atouches_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int atouches_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int econtains_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int econtains_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int econtains_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ecovers_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int ecovers_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int ecovers_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ecovers_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int edisjoint_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int edisjoint_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int edwithin_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern int edwithin_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb, double dist); +extern int edwithin_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2, double dist); +extern int eintersects_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int eintersects_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int eintersects_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern int etouches_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int etouches_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int etouches_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); + +/*****************************************************************************/ + +/* Spatiotemporal relationship functions */ + +extern Temporal *tcontains_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *tcontains_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcontains_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcontains_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tcontains_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tcovers_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *tcovers_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcovers_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcovers_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tcovers_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdwithin_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp, double dist); +extern Temporal *tdwithin_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern Temporal *tdwithin_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb, double dist); +extern Temporal *tdwithin_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2, double dist); +extern Temporal *tdisjoint_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *tdisjoint_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tdisjoint_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdisjoint_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tdisjoint_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tintersects_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *tintersects_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tintersects_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tintersects_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *tintersects_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); +extern Temporal *ttouches_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *ttouches_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *ttouches_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern Temporal *ttouches_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern Temporal *ttouches_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); + +/*****************************************************************************/ + +#endif /* __MEOS_CBUFFER_H__ */ +extern int acovers_cbuffer_tcbuffer(const Cbuffer *cb, const Temporal *temp); +extern int acovers_geo_tcbuffer(const GSERIALIZED *gs, const Temporal *temp); +extern int acovers_tcbuffer_cbuffer(const Temporal *temp, const Cbuffer *cb); +extern int acovers_tcbuffer_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int acovers_tcbuffer_tcbuffer(const Temporal *temp1, const Temporal *temp2); diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_geo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_geo.h new file mode 100644 index 0000000..7d54385 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_geo.h @@ -0,0 +1,900 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief API of the Mobility Engine Open Source (MEOS) library. + */ + +#ifndef __MEOS_GEO_H__ +#define __MEOS_GEO_H__ + +/* C */ +#include +#include + +/* PostGIS */ +#include +/* MEOS */ +#include + +/***************************************************************************** + * Type definitions + *****************************************************************************/ + +/** + * @brief Enumeration that defines the spatial relationships for which a call + * to GEOS is made. + */ +typedef enum +{ + INTERSECTS = 0, + CONTAINS = 1, + TOUCHES = 2, + COVERS = 3, +} spatialRel; + +/***************************************************************************** + * Validity macros + *****************************************************************************/ + +/** + * @brief Macro ensuring that a set is a geometry set + */ +#if MEOS + #define VALIDATE_GEOMSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type(set, T_GEOMSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_GEOMSET(set, ret) \ + do { \ + assert(temp); \ + assert((set)->settype == T_GEOMSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a set is a geography set + */ +#if MEOS + #define VALIDATE_GEOGSET(set, ret) ( \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type(set, T_GEOGSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_GEOGSET(set, ret) \ + do { \ + assert(temp); \ + assert((set)->settype == T_GEOGSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a set is of a geometry or geography set + */ +#if MEOS + #define VALIDATE_GEOSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_geoset_type((set)->settype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_GEOSET(set, ret) \ + do { \ + assert(temp); \ + assert(geoset_type((set)->settype); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a set is of a spatial set + */ +#if MEOS + #define VALIDATE_SPATIALSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_spatialset_type((set)->settype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_SPATIALSET(set, ret) \ + do { \ + assert(set); \ + assert(spatialset_type((set)->settype)); \ + } while (0) +#endif /* MEOS */ + +/*****************************************************************************/ + +/** + * @brief Macro ensuring that a temporal value is a temporal geometry + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOMETRY(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TGEOMETRY) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOMETRY(temp, ret) \ + do { \ + assert(temp); \ + assert((temp)->temptype == T_TGEOMETRY); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is a temporal geography + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOGRAPHY(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TGEOGRAPHY) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOGRAPHY(temp, ret) \ + do { \ + assert(temp); \ + assert((temp)->temptype == T_TGEOGRAPHY); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is a temporal geometry point + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOMPOINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TGEOMPOINT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOMPOINT(temp, ret) \ + do { \ + assert(temp); \ + assert((temp)->temptype == T_TGEOMPOINT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is a temporal geography point + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOGPOINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TGEOGPOINT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOGPOINT(temp, ret) \ + do { \ + assert(temp); \ + assert((temp)->temptype == T_TGEOGPOINT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is a temporal geometry or + * geography + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEO(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tgeo_type_all(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEO(temp, ret) \ + do { \ + assert(temp); \ + assert(tgeo_type_all(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is a temporal geometry + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOM(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tgeometry_type(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOM(temp, ret) \ + do { \ + assert(temp); \ + assert(tgeometry_type(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is of a temporal geography + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TGEOG(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tgeodetic_type(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TGEOG(temp, ret) \ + do { \ + assert(temp); \ + assert(tgeodetic_type(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is of a temporal + * geometry/geography point + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TPOINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tpoint_type(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TPOINT(temp, ret) \ + do { \ + assert(temp); \ + assert(tpoint_type(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro ensuring that a temporal value is of a spatiotemporal type + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TSPATIAL(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tspatial_type(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TSPATIAL(temp, ret) \ + do { \ + assert(temp); \ + assert(tspatial_type(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/*===========================================================================* + * Functions for static geometries + *===========================================================================*/ + +/* Input and output functions */ + +extern uint8_t *geo_as_ewkb(const GSERIALIZED *gs, const char *endian, size_t *size); +extern char *geo_as_ewkt(const GSERIALIZED *gs, int precision); +extern char *geo_as_geojson(const GSERIALIZED *gs, int option, int precision, const char *srs); +extern char *geo_as_hexewkb(const GSERIALIZED *gs, const char *endian); +extern char *geo_as_text(const GSERIALIZED *gs, int precision); +extern GSERIALIZED *geo_from_ewkb(const uint8_t *wkb, size_t wkb_size, int32 srid); +extern GSERIALIZED *geo_from_geojson(const char *geojson); +extern GSERIALIZED *geo_from_text(const char *wkt, int32_t srid); +extern char *geo_out(const GSERIALIZED *gs); +extern GSERIALIZED *geog_from_binary(const char *wkb_bytea); +extern GSERIALIZED *geog_from_hexewkb(const char *wkt); +extern GSERIALIZED *geog_in(const char *str, int32 typmod); +extern GSERIALIZED *geom_from_hexewkb(const char *wkt); +extern GSERIALIZED *geom_in(const char *str, int32 typmod); + +extern BOX3D *box3d_make(double xmin, double xmax, double ymin, double ymax, + double zmin, double zmax, int32_t srid); +extern char *box3d_out(const BOX3D *box, int maxdd); +extern GBOX *gbox_make(bool hasz, double xmin, double xmax, double ymin, + double ymax, double zmin, double zmax); +extern char *gbox_out(const GBOX *box, int maxdd); + +/* Constructor functions */ + +extern GSERIALIZED *geo_copy(const GSERIALIZED *g); +extern GSERIALIZED *geogpoint_make2d(int32_t srid, double x, double y); +extern GSERIALIZED *geogpoint_make3dz(int32_t srid, double x, double y, double z); +extern GSERIALIZED *geompoint_make2d(int32_t srid, double x, double y); +extern GSERIALIZED *geompoint_make3dz(int32_t srid, double x, double y, double z); + +/* Conversion functions */ + +extern GSERIALIZED *geom_to_geog(const GSERIALIZED *geom); +extern GSERIALIZED *geog_to_geom(const GSERIALIZED *geog); + +/* Accessor functions */ + +extern bool geo_is_empty(const GSERIALIZED *g); +extern bool geo_is_unitary(const GSERIALIZED *gs); +extern const char *geo_typename(int type); +extern double geog_area(const GSERIALIZED *g, bool use_spheroid); +extern GSERIALIZED *geog_centroid(const GSERIALIZED *g, bool use_spheroid); +extern double geog_length(const GSERIALIZED *g, bool use_spheroid); +extern double geog_perimeter(const GSERIALIZED *g, bool use_spheroid); +extern bool geom_azimuth(const GSERIALIZED *gs1, const GSERIALIZED *gs2, double *result); +extern double geom_length(const GSERIALIZED *gs); +extern double geom_perimeter(const GSERIALIZED *gs); +extern int line_numpoints(const GSERIALIZED *gs); +extern GSERIALIZED *line_point_n(const GSERIALIZED *geom, int n); + +/* Transformation functions */ + +extern GSERIALIZED *geo_reverse(const GSERIALIZED *gs); +extern GSERIALIZED *geo_round(const GSERIALIZED *gs, int maxdd); + +/* Spatial reference system functions */ + +extern GSERIALIZED *geo_set_srid(const GSERIALIZED *gs, int32_t srid); +extern int32_t geo_srid(const GSERIALIZED *gs); +extern GSERIALIZED *geo_transform(const GSERIALIZED *geom, int32_t srid_to); +extern GSERIALIZED *geo_transform_pipeline(const GSERIALIZED *gs, char *pipeline, int32_t srid_to, bool is_forward); + +/* Spatial processing functions */ + +extern GSERIALIZED *geo_collect_garray(GSERIALIZED **gsarr, int count); +extern GSERIALIZED *geo_makeline_garray(GSERIALIZED **gsarr, int count); +extern int geo_num_points(const GSERIALIZED *gs); +extern int geo_num_geos(const GSERIALIZED *gs); +extern GSERIALIZED *geo_geo_n(const GSERIALIZED *geom, int n); +extern GSERIALIZED **geo_pointarr(const GSERIALIZED *gs, int *count); +extern GSERIALIZED *geo_points(const GSERIALIZED *gs); +extern GSERIALIZED *geom_array_union(GSERIALIZED **gsarr, int count); +extern GSERIALIZED *geom_boundary(const GSERIALIZED *gs); +extern GSERIALIZED *geom_buffer(const GSERIALIZED *gs, double size, const char *params); +extern GSERIALIZED *geom_centroid(const GSERIALIZED *gs); +extern GSERIALIZED *geom_convex_hull(const GSERIALIZED *gs); +extern GSERIALIZED *geom_difference2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *geom_intersection2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *geom_intersection2d_coll(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *geom_min_bounding_radius(const GSERIALIZED *geom, double *radius); +extern GSERIALIZED *geom_shortestline2d(const GSERIALIZED *gs1, const GSERIALIZED *s2); +extern GSERIALIZED *geom_shortestline3d(const GSERIALIZED *gs1, const GSERIALIZED *s2); +extern GSERIALIZED *geom_unary_union(const GSERIALIZED *gs, double prec); +extern GSERIALIZED *line_interpolate_point(const GSERIALIZED *gs, double distance_fraction, bool repeat); +extern double line_locate_point(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern GSERIALIZED *line_substring(const GSERIALIZED *gs, double from, double to); + +/* Spatial relationship functions */ + +extern bool geog_dwithin(const GSERIALIZED *g1, const GSERIALIZED *g2, double tolerance, bool use_spheroid); +extern bool geog_intersects(const GSERIALIZED *gs1, const GSERIALIZED *gs2, bool use_spheroid); +extern bool geom_contains(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geom_covers(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geom_disjoint2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geom_dwithin2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2, double tolerance); +extern bool geom_dwithin3d(const GSERIALIZED *gs1, const GSERIALIZED *gs2, double tolerance); +extern bool geom_intersects2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geom_intersects3d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geom_relate_pattern(const GSERIALIZED *gs1, const GSERIALIZED *gs2, char *patt); +extern bool geom_touches(const GSERIALIZED *gs1, const GSERIALIZED *gs2); + +/* Bounding box functions */ + +extern STBox *geo_stboxes(const GSERIALIZED *gs, int *count); +extern STBox *geo_split_each_n_stboxes(const GSERIALIZED *gs, int elem_count, int *count); +extern STBox *geo_split_n_stboxes(const GSERIALIZED *gs, int box_count, int *count); + +/* Distance functions */ + +extern double geog_distance(const GSERIALIZED *g1, const GSERIALIZED *g2); +extern double geom_distance2d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern double geom_distance3d(const GSERIALIZED *gs1, const GSERIALIZED *gs2); + +/* Comparison functions */ + +extern int geo_equals(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern bool geo_same(const GSERIALIZED *gs1, const GSERIALIZED *gs2); + +/***************************************************************************** + * Functions for spatial sets + *****************************************************************************/ + +/* Input and output functions */ + +extern Set *geogset_in(const char *str); +extern Set *geomset_in(const char *str); +extern char *spatialset_as_text(const Set *set, int maxdd); +extern char *spatialset_as_ewkt(const Set *set, int maxdd); + +/* Constructor functions */ + +extern Set *geoset_make(GSERIALIZED **values, int count); + +/* Conversion functions */ + +extern Set *geo_to_set(const GSERIALIZED *gs); + +/* Accessor functions */ + +extern GSERIALIZED *geoset_end_value(const Set *s); +extern GSERIALIZED *geoset_start_value(const Set *s); +extern bool geoset_value_n(const Set *s, int n, GSERIALIZED **result); +extern GSERIALIZED **geoset_values(const Set *s); + +/* Set operations */ + +extern bool contained_geo_set(const GSERIALIZED *gs, const Set *s); +extern bool contains_set_geo(const Set *s, GSERIALIZED *gs); +extern Set *geo_union_transfn(Set *state, const GSERIALIZED *gs); +extern Set *intersection_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *intersection_set_geo(const Set *s, const GSERIALIZED *gs); +extern Set *minus_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *minus_set_geo(const Set *s, const GSERIALIZED *gs); +extern Set *union_geo_set(const GSERIALIZED *gs, const Set *s); +extern Set *union_set_geo(const Set *s, const GSERIALIZED *gs); + +/* SRID functions */ + +extern Set *spatialset_set_srid(const Set *s, int32_t srid); +extern int32_t spatialset_srid(const Set *s); +extern Set *spatialset_transform(const Set *s, int32_t srid); +extern Set *spatialset_transform_pipeline(const Set *s, const char *pipelinestr, int32_t srid, bool is_forward); + +/***************************************************************************** + * Functions for spatiotemporal boxes + *****************************************************************************/ + +/* Input/output functions */ + +extern char *stbox_as_hexwkb(const STBox *box, uint8_t variant, size_t *size); +extern uint8_t *stbox_as_wkb(const STBox *box, uint8_t variant, size_t *size_out); +extern STBox *stbox_from_hexwkb(const char *hexwkb); +extern STBox *stbox_from_wkb(const uint8_t *wkb, size_t size); +extern STBox *stbox_in(const char *str); +extern char *stbox_out(const STBox *box, int maxdd); + +/* Constructor functions */ + +extern STBox *geo_timestamptz_to_stbox(const GSERIALIZED *gs, TimestampTz t); +extern STBox *geo_tstzspan_to_stbox(const GSERIALIZED *gs, const Span *s); +extern STBox *stbox_copy(const STBox *box); +extern STBox *stbox_make(bool hasx, bool hasz, bool geodetic, int32 srid, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, const Span *s); + +/* Conversion functions */ + +extern STBox *geo_to_stbox(const GSERIALIZED *gs); +extern STBox *spatialset_to_stbox(const Set *s); +extern BOX3D *stbox_to_box3d(const STBox *box); +extern GBOX *stbox_to_gbox(const STBox *box); +extern GSERIALIZED *stbox_to_geo(const STBox *box); +extern Span *stbox_to_tstzspan(const STBox *box); +extern STBox *timestamptz_to_stbox(TimestampTz t); +extern STBox *tstzset_to_stbox(const Set *s); +extern STBox *tstzspan_to_stbox(const Span *s); +extern STBox *tstzspanset_to_stbox(const SpanSet *ss); + +/* Accessor functions */ + +extern double stbox_area(const STBox *box, bool spheroid); +extern uint32 stbox_hash(const STBox *box); +extern uint64 stbox_hash_extended(const STBox *box, uint64 seed); +extern bool stbox_hast(const STBox *box); +extern bool stbox_hasx(const STBox *box); +extern bool stbox_hasz(const STBox *box); +extern bool stbox_isgeodetic(const STBox *box); +extern double stbox_perimeter(const STBox *box, bool spheroid); +extern bool stbox_tmax(const STBox *box, TimestampTz *result); +extern bool stbox_tmax_inc(const STBox *box, bool *result); +extern bool stbox_tmin(const STBox *box, TimestampTz *result); +extern bool stbox_tmin_inc(const STBox *box, bool *result); +extern double stbox_volume(const STBox *box); +extern bool stbox_xmax(const STBox *box, double *result); +extern bool stbox_xmin(const STBox *box, double *result); +extern bool stbox_ymax(const STBox *box, double *result); +extern bool stbox_ymin(const STBox *box, double *result); +extern bool stbox_zmax(const STBox *box, double *result); +extern bool stbox_zmin(const STBox *box, double *result); + +/* Transformation functions */ + +extern STBox *stbox_expand_space(const STBox *box, double d); +extern STBox *stbox_expand_time(const STBox *box, const Interval *interv); +extern STBox *stbox_get_space(const STBox *box); +extern STBox *stbox_quad_split(const STBox *box, int *count); +extern STBox *stbox_round(const STBox *box, int maxdd); +extern STBox *stbox_shift_scale_time(const STBox *box, const Interval *shift, const Interval *duration); +extern STBox *stboxarr_round(const STBox *boxarr, int count, int maxdd); + +/* SRID functions */ + +extern STBox *stbox_set_srid(const STBox *box, int32_t srid); +extern int32_t stbox_srid(const STBox *box); +extern STBox *stbox_transform(const STBox *box, int32_t srid); +extern STBox *stbox_transform_pipeline(const STBox *box, const char *pipelinestr, int32_t srid, bool is_forward); + +/* Topological functions */ + +extern bool adjacent_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool contained_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool contains_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overlaps_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool same_stbox_stbox(const STBox *box1, const STBox *box2); + +/* Position functions */ + +extern bool above_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool after_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool back_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool before_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool below_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool front_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool left_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overabove_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overafter_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overback_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overbefore_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overbelow_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overfront_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overleft_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool overright_stbox_stbox(const STBox *box1, const STBox *box2); +extern bool right_stbox_stbox(const STBox *box1, const STBox *box2); + +/* Set functions */ + +extern STBox *union_stbox_stbox(const STBox *box1, const STBox *box2, bool strict); +extern STBox *intersection_stbox_stbox(const STBox *box1, const STBox *box2); + +/* Comparisons */ + +extern int stbox_cmp(const STBox *box1, const STBox *box2); +extern bool stbox_eq(const STBox *box1, const STBox *box2); +extern bool stbox_ge(const STBox *box1, const STBox *box2); +extern bool stbox_gt(const STBox *box1, const STBox *box2); +extern bool stbox_le(const STBox *box1, const STBox *box2); +extern bool stbox_lt(const STBox *box1, const STBox *box2); +extern bool stbox_ne(const STBox *box1, const STBox *box2); + +/***************************************************************************** + * Functions for temporal geometries/geographies + *****************************************************************************/ + +/* Input and output functions */ + +extern Temporal *tgeogpoint_from_mfjson(const char *str); +extern Temporal *tgeogpoint_in(const char *str); +extern Temporal *tgeography_from_mfjson(const char *mfjson); +extern Temporal *tgeography_in(const char *str); +extern Temporal *tgeometry_from_mfjson(const char *str); +extern Temporal *tgeometry_in(const char *str); +extern Temporal *tgeompoint_from_mfjson(const char *str); +extern Temporal *tgeompoint_in(const char *str); +extern char *tspatial_as_ewkt(const Temporal *temp, int maxdd); +extern char *tspatial_as_text(const Temporal *temp, int maxdd); +extern char *tspatial_out(const Temporal *temp, int maxdd); + +/* Constructor functions */ + +extern Temporal *tgeo_from_base_temp(const GSERIALIZED *gs, const Temporal *temp); +extern TInstant *tgeoinst_make(const GSERIALIZED *gs, TimestampTz t); +extern TSequence *tgeoseq_from_base_tstzset(const GSERIALIZED *gs, const Set *s); +extern TSequence *tgeoseq_from_base_tstzspan(const GSERIALIZED *gs, const Span *s, interpType interp); +extern TSequenceSet *tgeoseqset_from_base_tstzspanset(const GSERIALIZED *gs, const SpanSet *ss, interpType interp); +extern Temporal *tpoint_from_base_temp(const GSERIALIZED *gs, const Temporal *temp); +extern TInstant *tpointinst_make(const GSERIALIZED *gs, TimestampTz t); +extern TSequence *tpointseq_from_base_tstzset(const GSERIALIZED *gs, const Set *s); +extern TSequence *tpointseq_from_base_tstzspan(const GSERIALIZED *gs, const Span *s, interpType interp); +extern TSequence *tpointseq_make_coords(const double *xcoords, const double *ycoords, const double *zcoords, const TimestampTz *times, int count, int32 srid, bool geodetic, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequenceSet *tpointseqset_from_base_tstzspanset(const GSERIALIZED *gs, const SpanSet *ss, interpType interp); + +/* Conversion functions */ + +extern STBox *box3d_to_stbox(const BOX3D *box); +extern STBox *gbox_to_stbox(const GBOX *box); +extern Temporal *geomeas_to_tpoint(const GSERIALIZED *gs); +extern Temporal *tgeogpoint_to_tgeography(const Temporal *temp); +extern Temporal *tgeography_to_tgeogpoint(const Temporal *temp); +extern Temporal *tgeography_to_tgeometry(const Temporal *temp); +extern Temporal *tgeometry_to_tgeography(const Temporal *temp); +extern Temporal *tgeometry_to_tgeompoint(const Temporal *temp); +extern Temporal *tgeompoint_to_tgeometry(const Temporal *temp); +extern bool tpoint_as_mvtgeom(const Temporal *temp, const STBox *bounds, int32_t extent, int32_t buffer, bool clip_geom, GSERIALIZED **gsarr, int64 **timesarr, int *count); +extern bool tpoint_tfloat_to_geomeas(const Temporal *tpoint, const Temporal *measure, bool segmentize, GSERIALIZED **result); +extern STBox *tspatial_to_stbox(const Temporal *temp); + +/* Accessor functions */ + +extern bool bearing_point_point(const GSERIALIZED *gs1, const GSERIALIZED *gs2, double *result); +extern Temporal *bearing_tpoint_point(const Temporal *temp, const GSERIALIZED *gs, bool invert); +extern Temporal *bearing_tpoint_tpoint(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tgeo_centroid(const Temporal *temp); +extern GSERIALIZED *tgeo_convex_hull(const Temporal *temp); +extern GSERIALIZED *tgeo_end_value(const Temporal *temp); +extern GSERIALIZED *tgeo_start_value(const Temporal *temp); +extern GSERIALIZED *tgeo_traversed_area(const Temporal *temp, bool unary_union); +extern bool tgeo_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, GSERIALIZED **value); +extern bool tgeo_value_n(const Temporal *temp, int n, GSERIALIZED **result); +extern GSERIALIZED **tgeo_values(const Temporal *temp, int *count); +extern Temporal *tpoint_angular_difference(const Temporal *temp); +extern Temporal *tpoint_azimuth(const Temporal *temp); +extern Temporal *tpoint_cumulative_length(const Temporal *temp); +extern bool tpoint_direction(const Temporal *temp, double *result); +extern Temporal *tpoint_get_x(const Temporal *temp); +extern Temporal *tpoint_get_y(const Temporal *temp); +extern Temporal *tpoint_get_z(const Temporal *temp); +extern bool tpoint_is_simple(const Temporal *temp); +extern double tpoint_length(const Temporal *temp); +extern Temporal *tpoint_speed(const Temporal *temp); +extern GSERIALIZED *tpoint_trajectory(const Temporal *temp, bool unary_union); +extern GSERIALIZED *tpoint_twcentroid(const Temporal *temp); + +/* Transformation functions */ + +extern Temporal *tgeo_affine(const Temporal *temp, const AFFINE *a); +extern Temporal *tgeo_scale(const Temporal *temp, const GSERIALIZED *scale, const GSERIALIZED *sorigin); +extern Temporal **tpoint_make_simple(const Temporal *temp, int *count); + +/* SRID functions */ + +int32_t tspatial_srid(const Temporal *temp); +extern Temporal *tspatial_set_srid(const Temporal *temp, int32_t srid); +extern Temporal *tspatial_transform(const Temporal *temp, int32_t srid); +extern Temporal *tspatial_transform_pipeline(const Temporal *temp, const char *pipelinestr, int32_t srid, bool is_forward); + +/* Restriction functions */ + +extern Temporal *tgeo_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tgeo_at_stbox(const Temporal *temp, const STBox *box, bool border_inc); +extern Temporal *tgeo_at_value(const Temporal *temp, GSERIALIZED *gs); +extern Temporal *tgeo_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tgeo_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); +extern Temporal *tgeo_minus_value(const Temporal *temp, GSERIALIZED *gs); +extern Temporal *tpoint_at_elevation(const Temporal *temp, const Span *s); +extern Temporal *tpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpoint_at_value(const Temporal *temp, GSERIALIZED *gs); +extern Temporal *tpoint_minus_elevation(const Temporal *temp, const Span *s); +extern Temporal *tpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpoint_minus_value(const Temporal *temp, GSERIALIZED *gs); + +/* Ever and always comparisons */ + +extern int always_eq_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int always_eq_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int always_eq_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int always_ne_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int always_ne_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_eq_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_eq_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_ne_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_ne_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); + +/* Temporal comparisons */ + +extern Temporal *teq_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *teq_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tne_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tne_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); + +/* Bounding box functions */ + +extern STBox *tgeo_stboxes(const Temporal *temp, int *count); +extern STBox *tgeo_space_boxes(const Temporal *temp, double xsize, double ysize, double zsize, const GSERIALIZED *sorigin, bool bitmatrix, bool border_inc, int *count); +extern STBox *tgeo_space_time_boxes(const Temporal *temp, double xsize, double ysize, double zsize, const Interval *duration, const GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, bool border_inc, int *count); +extern STBox *tgeo_split_each_n_stboxes(const Temporal *temp, int elem_count, int *count); +extern STBox *tgeo_split_n_stboxes(const Temporal *temp, int box_count, int *count); + +/* Topological functions */ + +extern bool adjacent_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool adjacent_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool adjacent_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool contained_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool contained_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool contained_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool contains_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool contains_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool contains_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overlaps_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overlaps_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overlaps_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool same_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool same_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool same_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); + +/* Position functions */ + +extern bool above_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool above_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool above_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool after_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool after_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool after_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool back_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool back_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool back_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool before_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool before_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool before_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool below_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool below_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool below_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool front_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool front_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool front_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool left_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool left_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool left_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overabove_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overabove_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overabove_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overafter_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overafter_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overafter_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overback_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overback_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overback_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overbefore_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overbefore_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overbefore_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overbelow_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overbelow_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overbelow_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overfront_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overfront_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overfront_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overleft_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overleft_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overleft_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool overright_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool overright_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool overright_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); +extern bool right_stbox_tspatial(const STBox *box, const Temporal *temp); +extern bool right_tspatial_stbox(const Temporal *temp, const STBox *box); +extern bool right_tspatial_tspatial(const Temporal *temp1, const Temporal *temp2); + +/* Ever and always spatial relationships */ + +extern int acontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int acontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int acontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int adisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int adisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int adwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern int adwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist); +extern int aintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int aintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int atouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int atouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int atouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int econtains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int econtains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int econtains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int ecovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int ecovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ecovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int edisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int edisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int edwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern int edwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist); +extern int eintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int eintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int etouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int etouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern int etouches_tpoint_geo(const Temporal *temp, const GSERIALIZED *gs); + +/* Spatiotemporal relationships */ + +extern Temporal *tcontains_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcontains_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcontains_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tcovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tcovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tcovers_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdisjoint_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tdisjoint_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdisjoint_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdwithin_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp, double dist); +extern Temporal *tdwithin_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs, double dist); +extern Temporal *tdwithin_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double dist); +extern Temporal *tintersects_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tintersects_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tintersects_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern Temporal *ttouches_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *ttouches_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *ttouches_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); + +/* Distance */ + +extern Temporal *tdistance_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdistance_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern double nad_stbox_geo(const STBox *box, const GSERIALIZED *gs); +extern double nad_stbox_stbox(const STBox *box1, const STBox *box2); +extern double nad_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern double nad_tgeo_stbox(const Temporal *temp, const STBox *box); +extern double nad_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern TInstant *nai_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2); +extern double tgeoarr_tgeoarr_mindist(const Temporal **arr1, int count1, const Temporal **arr2, int count2); +extern double mindistance_tgeo_tgeo(const Temporal *temp1, const Temporal *temp2, double threshold); + +/* Aggregates */ + +extern Temporal *tpoint_tcentroid_finalfn(SkipList *state); +extern SkipList *tpoint_tcentroid_transfn(SkipList *state, Temporal *temp); +extern STBox *tspatial_extent_transfn(STBox *box, const Temporal *temp); + +/* Tile functions */ + +extern STBox *stbox_get_space_tile(const GSERIALIZED *point, double xsize, double ysize, double zsize, const GSERIALIZED *sorigin); +extern STBox *stbox_get_space_time_tile(const GSERIALIZED *point, TimestampTz t, double xsize, double ysize, double zsize, const Interval *duration, const GSERIALIZED *sorigin, TimestampTz torigin); +extern STBox *stbox_get_time_tile(TimestampTz t, const Interval *duration, TimestampTz torigin); +extern STBox *stbox_space_tiles(const STBox *bounds, double xsize, double ysize, double zsize, const GSERIALIZED *sorigin, bool border_inc, int *count); +extern STBox *stbox_space_time_tiles(const STBox *bounds, double xsize, double ysize, double zsize, const Interval *duration, const GSERIALIZED *sorigin, TimestampTz torigin, bool border_inc, int *count); +extern STBox *stbox_time_tiles(const STBox *bounds, const Interval *duration, TimestampTz torigin, bool border_inc, int *count); +extern Temporal **tgeo_space_split(const Temporal *temp, double xsize, double ysize, double zsize, const GSERIALIZED *sorigin, bool bitmatrix, bool border_inc, GSERIALIZED ***space_bins, int *count); +extern Temporal **tgeo_space_time_split(const Temporal *temp, double xsize, double ysize, double zsize, const Interval *duration, const GSERIALIZED *sorigin, TimestampTz torigin, bool bitmatrix, bool border_inc, GSERIALIZED ***space_bins, TimestampTz **time_bins, int *count); + +/* Clustering functions */ + +extern int *geo_cluster_kmeans(const GSERIALIZED **geoms, uint32_t ngeoms, uint32_t k); +extern uint32_t *geo_cluster_dbscan(const GSERIALIZED **geoms, uint32_t ngeoms, double tolerance, int minpoints, int *count); +extern GSERIALIZED **geo_cluster_intersecting(const GSERIALIZED **geoms, uint32_t ngeoms, int *count); +extern GSERIALIZED **geo_cluster_within(const GSERIALIZED **geoms, uint32_t ngeoms, double tolerance, int *count); + +/*****************************************************************************/ + +#endif +extern int acovers_geo_tgeo(const GSERIALIZED *gs, const Temporal *temp); +extern int acovers_tgeo_geo(const Temporal *temp, const GSERIALIZED *gs); diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_h3.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_h3.h new file mode 100644 index 0000000..2febc47 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_h3.h @@ -0,0 +1,197 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Public MEOS API for the temporal H3 index type (th3index). + * + * Implementations live in meos/src/h3/. The PG V1 wrappers in + * mobilitydb/src/h3/ call these symbols. + */ + +#ifndef __MEOS_H3_H__ +#define __MEOS_H3_H__ + +#include +#include +#include +#include +#include + +/***************************************************************************** + * Static h3index SQL type — analogue of meos_cbuffer.h's + * static-cbuffer section. + *****************************************************************************/ + +extern H3Index h3index_in(const char *str); +extern char *h3index_out(H3Index cell); + +/***************************************************************************** + * Type inheritance (analogue of meos_cbuffer.h's tcbuffer section) + *****************************************************************************/ + +/* Input */ +extern Temporal *th3index_in(const char *str); +extern TInstant *th3indexinst_in(const char *str); +extern TSequence *th3indexseq_in(const char *str, interpType interp); +extern TSequenceSet *th3indexseqset_in(const char *str); + +/* Constructors */ +extern Temporal *th3index_make(H3Index value, TimestampTz t); +extern TInstant *th3indexinst_make(H3Index value, TimestampTz t); +extern TSequence *th3indexseq_make(const H3Index *values, + const TimestampTz *times, int count, bool lower_inc, bool upper_inc); +extern TSequenceSet *th3indexseqset_make(const TSequence **sequences, int count); + +/* Accessors */ +extern H3Index th3index_start_value(const Temporal *temp); +extern H3Index th3index_end_value(const Temporal *temp); +extern bool th3index_value_n(const Temporal *temp, int n, H3Index *result); +extern H3Index *th3index_values(const Temporal *temp, int *count); +extern bool th3index_value_at_timestamptz(const Temporal *temp, TimestampTz t, + bool strict, H3Index *result); + +/* MEOS-level conversions to/from tbigint */ +extern Temporal *tbigint_to_th3index(const Temporal *temp); +extern Temporal *th3index_to_tbigint(const Temporal *temp); + +/***************************************************************************** + * Ever/always comparison operators + *****************************************************************************/ + +extern int ever_eq_h3index_th3index(H3Index cell, const Temporal *temp); +extern int ever_eq_th3index_h3index(const Temporal *temp, H3Index cell); +extern int ever_ne_h3index_th3index(H3Index cell, const Temporal *temp); +extern int ever_ne_th3index_h3index(const Temporal *temp, H3Index cell); +extern int always_eq_h3index_th3index(H3Index cell, const Temporal *temp); +extern int always_eq_th3index_h3index(const Temporal *temp, H3Index cell); +extern int always_ne_h3index_th3index(H3Index cell, const Temporal *temp); +extern int always_ne_th3index_h3index(const Temporal *temp, H3Index cell); +extern int ever_eq_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); +extern int ever_ne_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); +extern int always_eq_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); +extern int always_ne_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); + +/***************************************************************************** + * Temporal comparison operators + *****************************************************************************/ + +extern Temporal *teq_h3index_th3index(H3Index cell, const Temporal *temp); +extern Temporal *teq_th3index_h3index(const Temporal *temp, H3Index cell); +extern Temporal *teq_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); +extern Temporal *tne_h3index_th3index(H3Index cell, const Temporal *temp); +extern Temporal *tne_th3index_h3index(const Temporal *temp, H3Index cell); +extern Temporal *tne_th3index_th3index(const Temporal *temp1, + const Temporal *temp2); + +/***************************************************************************** + * Inspection + *****************************************************************************/ + +extern Temporal *th3index_get_resolution(const Temporal *temp); +extern Temporal *th3index_get_base_cell_number(const Temporal *temp); +extern Temporal *th3index_is_valid_cell(const Temporal *temp); +extern Temporal *th3index_is_res_class_iii(const Temporal *temp); +extern Temporal *th3index_is_pentagon(const Temporal *temp); + +/***************************************************************************** + * Hierarchy + *****************************************************************************/ + +extern Temporal *th3index_cell_to_parent(const Temporal *temp, int32 resolution); +extern Temporal *th3index_cell_to_parent_next(const Temporal *temp); +extern Temporal *th3index_cell_to_center_child(const Temporal *temp, int32 resolution); +extern Temporal *th3index_cell_to_center_child_next(const Temporal *temp); +extern Temporal *th3index_cell_to_child_pos(const Temporal *temp, int32 parent_res); +extern Temporal *th3index_child_pos_to_cell(const Temporal *child_pos, + const Temporal *parent, int32 child_res); + +/***************************************************************************** + * Lat/Lng conversion + *****************************************************************************/ + +extern Temporal *tgeogpoint_to_th3index(const Temporal *temp, int32 resolution); +extern Temporal *tgeompoint_to_th3index(const Temporal *temp, int32 resolution); +extern Temporal *th3index_to_tgeogpoint(const Temporal *temp); +extern Temporal *th3index_to_tgeompoint(const Temporal *temp); +extern Temporal *th3index_cell_to_boundary(const Temporal *temp); + +/* Static geometry → H3 cell / cell set. See meos/src/h3/h3_geo.c. */ +extern H3Index h3_gs_point_to_cell(const GSERIALIZED *point, int32 resolution); +extern Set *geo_to_h3index_set(const GSERIALIZED *gs, int32 resolution); +extern int ever_eq_h3indexset_th3index(const Set *cells, + const Temporal *th3idx); + +/***************************************************************************** + * Directed edges + *****************************************************************************/ + +extern Temporal *th3index_are_neighbor_cells(const Temporal *origin, + const Temporal *dest); +extern Temporal *th3index_cells_to_directed_edge(const Temporal *origin, + const Temporal *dest); +extern Temporal *th3index_is_valid_directed_edge(const Temporal *edge); +extern Temporal *th3index_get_directed_edge_origin(const Temporal *edge); +extern Temporal *th3index_get_directed_edge_destination(const Temporal *edge); +extern Temporal *th3index_directed_edge_to_boundary(const Temporal *edge); + +/***************************************************************************** + * Vertices + *****************************************************************************/ + +extern Temporal *th3index_cell_to_vertex(const Temporal *temp, int32 vertex_num); +extern Temporal *th3index_vertex_to_latlng(const Temporal *temp); +extern Temporal *th3index_is_valid_vertex(const Temporal *temp); + +/***************************************************************************** + * Grid traversal + *****************************************************************************/ + +extern Temporal *th3index_grid_distance(const Temporal *origin, + const Temporal *dest); +extern Temporal *th3index_cell_to_local_ij(const Temporal *origin, + const Temporal *cell); +extern Temporal *th3index_local_ij_to_cell(const Temporal *origin, + const Temporal *coord); + +/***************************************************************************** + * Metrics + *****************************************************************************/ + +extern Temporal *th3index_cell_area(const Temporal *temp, const char *unit); +extern Temporal *th3index_edge_length(const Temporal *temp, const char *unit); +extern Temporal *tgeogpoint_great_circle_distance(const Temporal *a, + const Temporal *b, const char *unit); + +#endif /* __MEOS_H3_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal.h new file mode 100644 index 0000000..5791740 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal.h @@ -0,0 +1,1405 @@ +/***************************************************************************** + * + * This MobilityDB code seq provided under The PostgreSQL License. + * Copyright(c) 2016-2023, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License(GPLv2 or later). + * Copyright(c) 2001-2023, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement seq hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Internal API of the Mobility Engine Open Source(MEOS) library. + */ + +#ifndef __MEOS_INTERNAL_H__ +#define __MEOS_INTERNAL_H__ + +/* C */ +#include +/* JSON-C */ +#include +/* GSL */ +#include +#include +/* PROJ */ +#include +/* PostgreSQL */ +/* MEOS */ +#include +#include "temporal/meos_catalog.h" /* For MeosType */ + +/***************************************************************************** + * Validity macros + *****************************************************************************/ + +/** + * @brief Macro for ensuring that a pointer is not null + */ +#if MEOS + #define VALIDATE_NOT_NULL(ptr, ret) \ + do { if (! ensure_not_null((void *) (ptr))) return (ret); } while (0) +#else + #define VALIDATE_NOT_NULL(ptr, ret) \ + do { assert(ptr); } while (0) +#endif /* MEOS */ + +/*****************************************************************************/ + +/** + * @brief Macro for ensuring that a set is an integer set + */ +#if MEOS + #define VALIDATE_INTSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_INTSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_INTSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_INTSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a set is a big integer set + */ +#if MEOS + #define VALIDATE_BIGINTSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_BIGINTSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_BIGINTSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_BIGINTSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a set is a float set + */ +#if MEOS + #define VALIDATE_FLOATSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_FLOATSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_FLOATSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_FLOATSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a set is a text set + */ +#if MEOS + #define VALIDATE_TEXTSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_TEXTSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TEXTSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_TEXTSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a set is a date set + */ +#if MEOS + #define VALIDATE_DATESET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_DATESET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_DATESET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_DATESET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a set is a timestamptz set + */ +#if MEOS + #define VALIDATE_TSTZSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_TSTZSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TSTZSET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_TSTZSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the span is a number span + */ +#if MEOS + #define VALIDATE_NUMSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_numset_type((set)->settype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_NUMSET(set, ret) \ + do { \ + assert(set); \ + assert(numset_type((set)->settype)); \ + } while (0) +#endif /* MEOS */ + +/*****************************************************************************/ + +/** + * @brief Macro for ensuring that a span is an integer span + */ +#if MEOS + #define VALIDATE_INTSPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_span_isof_type((span), T_INTSPAN) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_INTSPAN(span, ret) \ + do { \ + assert(span); \ + assert((span)->spantype == T_INTSPAN); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span is a big integer span + */ +#if MEOS + #define VALIDATE_BIGINTSPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_span_isof_type((span), T_BIGINTSPAN) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_BIGINTSPAN(span, ret) \ + do { \ + assert(span); \ + assert((span)->spantype == T_BIGINTSPAN); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span is a float span + */ +#if MEOS + #define VALIDATE_FLOATSPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_span_isof_type((span), T_FLOATSPAN) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_FLOATSPAN(span, ret) \ + do { \ + assert(span); \ + assert((span)->spantype == T_FLOATSPAN); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span is a date span + */ +#if MEOS + #define VALIDATE_DATESPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_span_isof_type((span), T_DATESPAN) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_DATESPAN(span, ret) \ + do { \ + assert(span); \ + assert((span)->spantype == T_DATESPAN); \ + } while (0) +#endif /* MEOS */ + + +/** + * @brief Macro for ensuring that the span is a timestamptz span + */ +#if MEOS + #define VALIDATE_TSTZSPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_span_isof_type((span), T_TSTZSPAN) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TSTZSPAN(span, ret) \ + do { \ + assert(span); \ + assert((span)->spantype == T_TSTZSPAN); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the span is a number span + */ +#if MEOS + #define VALIDATE_NUMSPAN(span, ret) \ + do { \ + if (! ensure_not_null((void *) (span)) || \ + ! ensure_numspan_type((span)->spantype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_NUMSPAN(span, ret) \ + do { \ + assert(span); \ + assert(numspan_type((span)->spantype)); \ + } while (0) +#endif /* MEOS */ + +/*****************************************************************************/ + +/** + * @brief Macro for ensuring that a span set is an integer span set + */ +#if MEOS + #define VALIDATE_INTSPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_spanset_isof_type((ss), T_INTSPANSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_INTSPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert((ss)->spansettype == T_INTSPANSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span set is a big integer span set + */ +#if MEOS + #define VALIDATE_BIGINTSPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_spanset_isof_type((ss), T_BIGINTSPANSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_BIGINTSPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert((ss)->spansettype == T_BIGINTSPANSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span set is a float span set + */ +#if MEOS + #define VALIDATE_FLOATSPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_spanset_isof_type((ss), T_FLOATSPANSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_FLOATSPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert((ss)->spansettype == T_FLOATSPANSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that a span set is a date span set + */ +#if MEOS + #define VALIDATE_DATESPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_spanset_isof_type((ss), T_DATESPANSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_DATESPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert((ss)->spansettype == T_DATESPANSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the span set is a timestamptz span set + */ +#if MEOS + #define VALIDATE_TSTZSPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_spanset_isof_type(ss, T_TSTZSPANSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TSTZSPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert((ss)->spansettype == T_TSTZSPANSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the span set is a number span set + */ +#if MEOS + #define VALIDATE_NUMSPANSET(ss, ret) \ + do { \ + if (! ensure_not_null((void *) (ss)) || \ + ! ensure_numspanset_type((ss)->spansettype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_NUMSPANSET(ss, ret) \ + do { \ + assert(ss); \ + assert(numspanset_type((ss)->spansettype)); \ + } while (0) +#endif /* MEOS */ + +/*****************************************************************************/ + +/** + * @brief Macro for ensuring that the temporal value is a temporal Boolean + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TBOOL(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TBOOL) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TBOOL(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TBOOL); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value is a temporal integer + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TINT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TINT(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TINT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value is a temporal big integer + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TBIGINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TBIGINT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TBIGINT(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TBIGINT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value is a temporal float + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TFLOAT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TFLOAT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TFLOAT(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TFLOAT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value is a temporal text + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TTEXT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TTEXT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TTEXT(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TTEXT); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value is a temporal number + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TNUMBER(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_tnumber_type(((Temporal *) (temp))->temptype) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TNUMBER(temp, ret) \ + do { \ + assert(temp); \ + assert(tnumber_type(((Temporal *) (temp))->temptype)); \ + } while (0) +#endif /* MEOS */ + +/***************************************************************************** + * Macros for manipulating the 'flags' element where the less significant + * bits are MGTZXIICB, where + * M: (GEOM) the reference geometry is stored + * G: coordinates are geodetic + * T: has T coordinate, + * Z: has Z coordinate + * X: has value or X coordinate + * II: interpolation, whose values are + * - 00: INTERP_NONE (undetermined) for TInstant + * - 01: DISCRETE + * - 10: STEP + * - 11: LINEAR + * C: continuous base type / Ordered set + * B: base type passed by value + * Notice that the interpolation flags are only needed for sequence and + * sequence set subtypes. + *****************************************************************************/ + +/* The following flag is only used for Set and TInstant */ +#define MEOS_FLAG_BYVAL 0x0001 // 1 +/* The following flag is only used for Set */ +#define MEOS_FLAG_ORDERED 0x0002 // 2 +/* The following flag is only used for Temporal */ +#define MEOS_FLAG_CONTINUOUS 0x0002 // 2 +/* The following two interpolation flags are only used for TSequence and TSequenceSet */ +#define MEOS_FLAGS_INTERP 0x000C // 4 / 8 +/* The following two flags are used for both bounding boxes and temporal types */ +#define MEOS_FLAG_X 0x0010 // 16 +#define MEOS_FLAG_Z 0x0020 // 32 +#define MEOS_FLAG_T 0x0040 // 64 +#define MEOS_FLAG_GEODETIC 0x0080 // 128 +#define MEOS_FLAG_GEOM 0x0100 // 256 + +#define MEOS_FLAGS_GET_BYVAL(flags) ((bool) (((flags) & MEOS_FLAG_BYVAL))) +#define MEOS_FLAGS_GET_ORDERED(flags) ((bool) (((flags) & MEOS_FLAG_ORDERED)>>1)) +#define MEOS_FLAGS_GET_CONTINUOUS(flags) ((bool) (((flags) & MEOS_FLAG_CONTINUOUS)>>1)) +#define MEOS_FLAGS_GET_X(flags) ((bool) (((flags) & MEOS_FLAG_X)>>4)) +#define MEOS_FLAGS_GET_Z(flags) ((bool) (((flags) & MEOS_FLAG_Z)>>5)) +#define MEOS_FLAGS_GET_T(flags) ((bool) (((flags) & MEOS_FLAG_T)>>6)) +#define MEOS_FLAGS_GET_GEODETIC(flags) ((bool) (((flags) & MEOS_FLAG_GEODETIC)>>7)) +#define MEOS_FLAGS_GET_GEOM(flags) ((bool) (((flags) & MEOS_FLAG_GEOM)>>8)) + +#define MEOS_FLAGS_BYREF(flags) ((bool) (((flags) & ! MEOS_FLAG_BYVAL))) + +#define MEOS_FLAGS_SET_BYVAL(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_BYVAL) : ((flags) & ~MEOS_FLAG_BYVAL)) +#define MEOS_FLAGS_SET_ORDERED(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_ORDERED) : ((flags) & ~MEOS_FLAG_ORDERED)) +#define MEOS_FLAGS_SET_CONTINUOUS(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_CONTINUOUS) : ((flags) & ~MEOS_FLAG_CONTINUOUS)) +#define MEOS_FLAGS_SET_X(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_X) : ((flags) & ~MEOS_FLAG_X)) +#define MEOS_FLAGS_SET_Z(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_Z) : ((flags) & ~MEOS_FLAG_Z)) +#define MEOS_FLAGS_SET_T(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_T) : ((flags) & ~MEOS_FLAG_T)) +#define MEOS_FLAGS_SET_GEODETIC(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_GEODETIC) : ((flags) & ~MEOS_FLAG_GEODETIC)) +#define MEOS_FLAGS_SET_GEOM(flags, value) \ + ((flags) = (value) ? ((flags) | MEOS_FLAG_GEOM) : ((flags) & ~MEOS_FLAG_GEOM)) + +#define MEOS_FLAGS_GET_INTERP(flags) (((flags) & MEOS_FLAGS_INTERP) >> 2) +#define MEOS_FLAGS_SET_INTERP(flags, value) ((flags) = (((flags) & ~MEOS_FLAGS_INTERP) | ((value & 0x0003) << 2))) + +#define MEOS_FLAGS_DISCRETE_INTERP(flags) ((bool) (MEOS_FLAGS_GET_INTERP((flags)) == DISCRETE)) +#define MEOS_FLAGS_STEP_INTERP(flags) ((bool) (MEOS_FLAGS_GET_INTERP((flags)) == STEP)) +#define MEOS_FLAGS_LINEAR_INTERP(flags) ((bool) (MEOS_FLAGS_GET_INTERP((flags)) == LINEAR)) +#define MEOS_FLAGS_STEP_LINEAR_INTERP(flags) \ + ((bool) (MEOS_FLAGS_GET_INTERP((flags)) == STEP || MEOS_FLAGS_GET_INTERP((flags)) == LINEAR)) + +/***************************************************************************** + * Macros for speeding up access to component values + *****************************************************************************/ + +/* Macros for speeding up access to component values of sets and span sets */ + +#if DEBUG_BUILD +extern void *SET_BBOX_PTR(const Set *s); +extern size_t *SET_OFFSETS_PTR(const Set *s); +extern Datum SET_VAL_N(const Set *s, int index); +extern const Span *SPANSET_SP_N(const SpanSet *ss, int index); +#else +/** + * @brief Return a pointer to the bounding box of a set (if any) + */ +#define SET_BBOX_PTR(s) ( (void *)( \ + ((char *) (s)) + DOUBLE_PAD(sizeof(Set)) ) ) + +/** + * @brief Return a pointer to the offsets array of a set + */ +#define SET_OFFSETS_PTR(s) ( (size_t *)( \ + ((char *) (s)) + DOUBLE_PAD(sizeof(Set)) + DOUBLE_PAD((s)->bboxsize) ) ) + +/** + * @brief Return the n-th value of a set + * @pre The argument @p index is less than the number of values in the set + */ +#define SET_VAL_N(s, index) ( (Datum) ( \ + MEOS_FLAGS_GET_BYVAL((s)->flags) ? (SET_OFFSETS_PTR(s))[index] : \ + PointerGetDatum( ((char *) (s)) + DOUBLE_PAD(sizeof(Set)) + \ + DOUBLE_PAD((s)->bboxsize) + (sizeof(size_t) * (s)->maxcount) + \ + (SET_OFFSETS_PTR(s))[index] ) ) ) + +/** + * @brief Return the n-th span of a span set. + * @pre The argument @p index is less than the number of spans in the span set + * @note This is the macro equivalent to #spanset_span_n. + * This function does not verify that the index is is in the correct bounds + */ +#define SPANSET_SP_N(ss, index) (const Span *) &((ss)->elems[(index)]) +#endif + +/*****************************************************************************/ + +/* Macros for speeding up access to components of temporal sequences (sets)*/ + +#if DEBUG_BUILD +extern size_t *TSEQUENCE_OFFSETS_PTR(const TSequence *seq); +extern const TInstant *TSEQUENCE_INST_N(const TSequence *seq, int index); +extern size_t *TSEQUENCESET_OFFSETS_PTR(const TSequenceSet *ss); +extern const TSequence *TSEQUENCESET_SEQ_N(const TSequenceSet *ss, int index); +#else +/** + * @brief Return a pointer to the offsets array of a temporal sequence + * @note The period component of the bbox is already declared in the struct + */ +#define TSEQUENCE_OFFSETS_PTR(seq) ( (size_t *)( \ + ((char *) &((seq)->period)) + (seq)->bboxsize ) ) + +/** + * @brief Return the n-th instant of a temporal sequence. + * @note The period component of the bbox is already declared in the struct + * @pre The argument @p index is less than the number of instants in the + * sequence + */ +#define TSEQUENCE_INST_N(seq, index) ( (const TInstant *)( \ + ((char *) &((seq)->period)) + (seq)->bboxsize + \ + (sizeof(size_t) * (seq)->maxcount) + (TSEQUENCE_OFFSETS_PTR(seq))[index] ) ) + +/** + * @brief Return a pointer to the offsets array of a temporal sequence set + * @note The period component of the bbox is already declared in the struct + */ +#define TSEQUENCESET_OFFSETS_PTR(ss) ( (size_t *)( \ + ((char *) &((ss)->period)) + (ss)->bboxsize ) ) + +/** + * @brief Return the n-th sequence of a temporal sequence set + * @note The period component of the bbox is already declared in the struct + * @pre The argument @p index is less than the number of sequences in the + * sequence set + */ +#define TSEQUENCESET_SEQ_N(ss, index) ( (const TSequence *)( \ + ((char *) &((ss)->period)) + (ss)->bboxsize + \ + (sizeof(size_t) * (ss)->maxcount) + (TSEQUENCESET_OFFSETS_PTR(ss))[index] ) ) +#endif /* DEBUG_BUILD */ + +/*****************************************************************************/ + +/* Structure of an expandable arrays used in particular to avoid parsing twice + * a MEOS value input in text format */ + +#define MEOS_ARRAY_INITIAL_SIZE 256 + +/** + * @brief Structure of an expandable arrays used in particular to avoid parsing + * twice a MEOS value input in text format + */ +typedef struct MeosArray +{ + size_t capacity; /**< Total capacity in number of elements */ + size_t count; /**< Number of elements currently in use */ + size_t elem_size; /**< Size of a single element in bytes */ + bool varlength; /**< True if elements are pointers (stored as Datums); + the array does not own the pointed-to memory */ + void *elems; /**< Pointer to the array elements */ +} MeosArray; + + +/*****************************************************************************/ + +/** + * Structure to represent skiplist elements + */ + +#define SKIPLIST_MAXLEVEL 32 /**< maximum possible is 47 with current RNG */ + +typedef struct +{ + void *key; + void *value; + int height; + int next[SKIPLIST_MAXLEVEL]; +} SkipListElem; + +/** + * Structure to represent skiplists that keep the current state of an aggregation + */ +struct SkipList +{ + size_t key_size; /**< Size in bytes of the keys */ + size_t value_size; /**< Size in bytes of the values */ + int capacity; /**< Maximum number of elements */ + int length; /**< Number of elements */ + int next; /**< Index of the next free element */ + int tail; /**< Index of the tail element */ + int *freed; /**< Array of index values of deleted elements */ + int freecount; /**< Number of deleted elements */ + int freecap; /**< Maximum number of deleted elements */ + void *extra; /**< Pointer to additional data needed for processing */ + size_t extrasize; /**< Size of additional data needed for processing */ + int (*comp_fn)(void *, void *); /**< Comparison function for the elements */ + void *(*merge_fn)(void *, void *); /**< Merge function for the elements */ + SkipListElem *elems; /**< Array of elements */ +}; + +/** + * @brief Enumeration for the relative position of a given element into a + * skiplist + */ +typedef enum +{ + TEMPORAL, + KEYVALUE +} SkipListType; + +/***************************************************************************** + * Definition of a function with one to three Datum arguments and returning + * a Datum + *****************************************************************************/ + +typedef Datum (*datum_func1) (Datum); +typedef Datum (*datum_func2) (Datum, Datum); +typedef Datum (*datum_func3) (Datum, Datum, Datum); + +/***************************************************************************** + * Internal function accessing the Gnu Scientic Library (GSL) + *****************************************************************************/ + +extern gsl_rng *gsl_get_generation_rng(void); +extern gsl_rng *gsl_get_aggregation_rng(void); + +/***************************************************************************** + * Generic type functions + *****************************************************************************/ + +#if MEOS +#define TimestampTzGetDatum(X) Int64GetDatum(X) +#define DatumGetTimestampTz(X)((TimestampTz) DatumGetInt64(X)) +#endif /* MEOS */ + +extern Datum datum_ceil(Datum d); +extern Datum datum_degrees(Datum d, Datum normalize); +extern Datum datum_float_round(Datum value, Datum size); +extern Datum datum_floor(Datum d); +extern uint32 datum_hash(Datum d, MeosType basetype); +extern uint64 datum_hash_extended(Datum d, MeosType basetype, uint64 seed); +extern Datum datum_radians(Datum d); +extern void floatspan_round_set(const Span *s, int maxdd, Span *result); + +/***************************************************************************** + * Functions for set and span types + *****************************************************************************/ + +/* Input and output functions for set and span types */ + +extern Set *set_in(const char *str, MeosType basetype); +extern char *set_out(const Set *s, int maxdd); +extern Span *span_in(const char *str, MeosType spantype); +extern char *span_out(const Span *s, int maxdd); +extern SpanSet *spanset_in(const char *str, MeosType spantype); +extern char *spanset_out(const SpanSet *ss, int maxdd); + +/*****************************************************************************/ + +/* Constructor functions for set and span types */ + +extern Set *set_make(const Datum *values, int count, MeosType basetype, bool order); +extern Set *set_make_exp(const Datum *values, int count, int maxcount, MeosType basetype, bool order); +extern Set *set_make_free(Datum *values, int count, MeosType basetype, bool order); +extern Span *span_make(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype); +extern void span_set(Datum lower, Datum upper, bool lower_inc, bool upper_inc, MeosType basetype, MeosType spantype, Span *s); +extern SpanSet *spanset_make_exp(Span *spans, int count, int maxcount, bool normalize, bool order); +extern SpanSet *spanset_make_free(Span *spans, int count, bool normalize, bool order); + +/*****************************************************************************/ + +/* Conversion functions for set and span types */ + +extern Span *set_span(const Set *s); +extern SpanSet *set_spanset(const Set *s); +extern void value_set_span(Datum value, MeosType basetype, Span *s); +extern Set *value_set(Datum d, MeosType basetype); +extern Span *value_span(Datum d, MeosType basetype); +extern SpanSet *value_spanset(Datum d, MeosType basetype); + +/*****************************************************************************/ + +/* Accessor functions for set and span types */ + +extern Datum numspan_width(const Span *s); +extern Datum numspanset_width(const SpanSet *ss, bool boundspan); +extern Datum set_end_value(const Set *s); +extern int set_mem_size(const Set *s); +extern void set_set_subspan(const Set *s, int minidx, int maxidx, Span *result); +extern void set_set_span(const Set *s, Span *result); +extern Datum set_start_value(const Set *s); +extern bool set_value_n(const Set *s, int n, Datum *result); +extern Datum *set_vals(const Set *s); +extern Datum *set_values(const Set *s); +extern Datum spanset_lower(const SpanSet *ss); +extern int spanset_mem_size(const SpanSet *ss); +extern const Span **spanset_sps(const SpanSet *ss); +extern Datum spanset_upper(const SpanSet *ss); + +/*****************************************************************************/ + +/* Transformation functions for set and span types */ + +extern void bigintspan_set_floatspan(const Span *s1, Span *s2); +extern void bigintspan_set_intspan(const Span *s1, Span *s2); +extern void datespan_set_tstzspan(const Span *s1, Span *s2); +extern void floatspan_set_bigintspan(const Span *s1, Span *s2); +extern void floatspan_set_intspan(const Span *s1, Span *s2); +extern void intspan_set_bigintspan(const Span *s1, Span *s2); +extern void intspan_set_floatspan(const Span *s1, Span *s2); +extern Set *numset_shift_scale(const Set *s, Datum shift, Datum width, bool hasshift, bool haswidth); +extern Span *numspan_expand(const Span *s, Datum value); +extern Span *numspan_shift_scale(const Span *s, Datum shift, Datum width, bool hasshift, bool haswidth); +extern SpanSet *numspanset_shift_scale(const SpanSet *ss, Datum shift, Datum width, bool hasshift, bool haswidth); +extern Set *set_compact(const Set *s); +extern void span_expand(const Span *s1, Span *s2); +extern SpanSet *spanset_compact(const SpanSet *ss); +extern TBox *tbox_expand_value(const TBox *box, Datum value, MeosType basetyp); +extern Set *textcat_textset_text_common(const Set *s, const text *txt, bool invert); +extern void tstzspan_set_datespan(const Span *s1, Span *s2); + +/***************************************************************************** + * Comparison functions for set and span types + *****************************************************************************/ + + +/***************************************************************************** + * Bounding box functions for set and span types + *****************************************************************************/ + +/* Topological functions for set and span types */ + +extern bool adjacent_span_value(const Span *s, Datum value); +extern bool adjacent_spanset_value(const SpanSet *ss, Datum value); +extern bool adjacent_value_spanset(Datum value, const SpanSet *ss); +extern bool contained_value_set(Datum value, const Set *s); +extern bool contained_value_span(Datum value, const Span *s); +extern bool contained_value_spanset(Datum value, const SpanSet *ss); +extern bool contains_set_value(const Set *s, Datum value); +extern bool contains_span_value(const Span *s, Datum value); +extern bool contains_spanset_value(const SpanSet *ss, Datum value); +extern bool ovadj_span_span(const Span *s1, const Span *s2); + +/*****************************************************************************/ + +/* Position functions for set and span types */ + +extern bool left_set_value(const Set *s, Datum value); +extern bool left_span_value(const Span *s, Datum value); +extern bool left_spanset_value(const SpanSet *ss, Datum value); +extern bool left_value_set(Datum value, const Set *s); +extern bool left_value_span(Datum value, const Span *s); +extern bool left_value_spanset(Datum value, const SpanSet *ss); +extern bool lfnadj_span_span(const Span *s1, const Span *s2); +extern bool overleft_set_value(const Set *s, Datum value); +extern bool overleft_span_value(const Span *s, Datum value); +extern bool overleft_spanset_value(const SpanSet *ss, Datum value); +extern bool overleft_value_set(Datum value, const Set *s); +extern bool overleft_value_span(Datum value, const Span *s); +extern bool overleft_value_spanset(Datum value, const SpanSet *ss); +extern bool overright_set_value(const Set *s, Datum value); +extern bool overright_span_value(const Span *s, Datum value); +extern bool overright_spanset_value(const SpanSet *ss, Datum value); +extern bool overright_value_set(Datum value, const Set *s); +extern bool overright_value_span(Datum value, const Span *s); +extern bool overright_value_spanset(Datum value, const SpanSet *ss); +extern bool right_value_set(Datum value, const Set *s); +extern bool right_set_value(const Set *s, Datum value); +extern bool right_value_span(Datum value, const Span *s); +extern bool right_value_spanset(Datum value, const SpanSet *ss); +extern bool right_span_value(const Span *s, Datum value); +extern bool right_spanset_value(const SpanSet *ss, Datum value); + +/*****************************************************************************/ + +/* Functions on generic bounding boxes of temporal types */ + +extern bool bbox_type(MeosType bboxtype); +extern size_t bbox_get_size(MeosType bboxtype); +extern int bbox_max_dims(MeosType bboxtype); +extern bool temporal_bbox_eq(const void *box1, const void *box2, + MeosType temptype); +extern int temporal_bbox_cmp(const void *box1, const void *box2, + MeosType temptype); + +/* Set functions for set and span types */ + +extern void bbox_union_span_span(const Span *s1, const Span *s2, Span *result); +extern bool inter_span_span(const Span *s1, const Span *s2, Span *result); +extern Set *intersection_set_value(const Set *s, Datum value); +extern Span *intersection_span_value(const Span *s, Datum value); +extern SpanSet *intersection_spanset_value(const SpanSet *ss, Datum value); +extern Set *intersection_value_set(Datum value, const Set *s); +extern Span *intersection_value_span(Datum value, const Span *s); +extern SpanSet *intersection_value_spanset(Datum value, const SpanSet *ss); +extern int mi_span_span(const Span *s1, const Span *s2, Span *result); +extern Set *minus_set_value(const Set *s, Datum value); +extern SpanSet *minus_span_value(const Span *s, Datum value); +extern SpanSet *minus_spanset_value(const SpanSet *ss, Datum value); +extern Set *minus_value_set(Datum value, const Set *s); +extern SpanSet *minus_value_span(Datum value, const Span *s); +extern SpanSet *minus_value_spanset(Datum value, const SpanSet *ss); +extern Span *super_union_span_span(const Span *s1, const Span *s2); +extern Set *union_set_value(const Set *s, Datum value); +extern SpanSet *union_span_value(const Span *s, Datum value); +extern SpanSet *union_spanset_value(const SpanSet *ss, Datum value); +extern Set *union_value_set(Datum value, const Set *s); +extern SpanSet *union_value_span(Datum value, const Span *s); +extern SpanSet *union_value_spanset(Datum value, const SpanSet *ss); + +/*****************************************************************************/ + +/* Distance functions for set and span types */ + +extern Datum distance_set_set(const Set *s1, const Set *s2); +extern Datum distance_set_value(const Set *s, Datum value); +extern Datum distance_span_span(const Span *s1, const Span *s2); +extern Datum distance_span_value(const Span *s, Datum value); +extern Datum distance_spanset_span(const SpanSet *ss, const Span *s); +extern Datum distance_spanset_spanset(const SpanSet *ss1, const SpanSet *ss2); +extern Datum distance_spanset_value(const SpanSet *ss, Datum value); +extern Datum distance_value_value(Datum l, Datum r, MeosType basetype); + +/*****************************************************************************/ + +/* Aggregate functions for set and span types */ + +extern Span *spanbase_extent_transfn(Span *state, Datum value, MeosType basetype); +extern Set *value_union_transfn(Set *state, Datum value, MeosType basetype); + +/****************************************************************************** + * Functions for box types + *****************************************************************************/ + +/* Constructor functions for box types */ + +extern TBox *number_tstzspan_to_tbox(Datum d, MeosType basetype, const Span *s); +extern TBox *number_timestamptz_to_tbox(Datum d, MeosType basetype, TimestampTz t); +extern void tbox_set(const Span *s, const Span *p, TBox *box); + +/*****************************************************************************/ + +/* Conversion functions for box types */ + +extern void float_set_tbox(double d, TBox *box); +extern void int_set_tbox(int i, TBox *box); +extern void number_set_tbox(Datum d, MeosType basetype, TBox *box); +extern TBox *number_tbox(Datum value, MeosType basetype); +extern void numset_set_tbox(const Set *s, TBox *box); +extern void numspan_set_tbox(const Span *span, TBox *box); +extern void timestamptz_set_tbox(TimestampTz t, TBox *box); +extern void tstzset_set_tbox(const Set *s, TBox *box); +extern void tstzspan_set_tbox(const Span *s, TBox *box); + +/*****************************************************************************/ + +/* Accessor functions for box types */ + + +/*****************************************************************************/ + +/* Transformation functions for box types */ + +extern TBox *tbox_shift_scale_value(const TBox *box, Datum shift, Datum width, bool hasshift, bool haswidth); +extern void tbox_expand(const TBox *box1, TBox *box2); + +/*****************************************************************************/ + +/* Set functions for box types */ + +extern bool inter_tbox_tbox(const TBox *box1, const TBox *box2, TBox *result); + +/***************************************************************************** + * Functions for temporal types + *****************************************************************************/ + +/* Input and output functions for temporal types */ + +extern TInstant *tboolinst_from_mfjson(json_object *mfjson); +extern TInstant *tboolinst_in(const char *str); +extern TSequence *tboolseq_from_mfjson(json_object *mfjson); +extern TSequence *tboolseq_in(const char *str, interpType interp); +extern TSequenceSet *tboolseqset_from_mfjson(json_object *mfjson); +extern TSequenceSet *tboolseqset_in(const char *str); +extern Temporal *temporal_in(const char *str, MeosType temptype); +extern char *temporal_out(const Temporal *temp, int maxdd); +extern char **temparr_out(Temporal **temparr, int count, int maxdd); +extern TInstant *tfloatinst_from_mfjson(json_object *mfjson); +extern TInstant *tfloatinst_in(const char *str); +extern TSequence *tfloatseq_from_mfjson(json_object *mfjson, interpType interp); +extern TSequence *tfloatseq_in(const char *str, interpType interp); +extern TSequenceSet *tfloatseqset_from_mfjson(json_object *mfjson, interpType interp); +extern TSequenceSet *tfloatseqset_in(const char *str); +extern TInstant *tinstant_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype); +extern TInstant *tinstant_in(const char *str, MeosType temptype); +extern char *tinstant_out(const TInstant *inst, int maxdd); +extern TInstant *tintinst_from_mfjson(json_object *mfjson); +extern TInstant *tintinst_in(const char *str); +extern TSequence *tintseq_from_mfjson(json_object *mfjson); +extern TSequence *tintseq_in(const char *str, interpType interp); +extern TSequenceSet *tintseqset_from_mfjson(json_object *mfjson); +extern TSequenceSet *tintseqset_in(const char *str); +extern TSequence *tsequence_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); +extern TSequence *tsequence_in(const char *str, MeosType temptype, interpType interp); +extern char *tsequence_out(const TSequence *seq, int maxdd); +extern TSequenceSet *tsequenceset_from_mfjson(json_object *mfjson, bool spatial, int32_t srid, MeosType temptype, interpType interp); +extern TSequenceSet *tsequenceset_in(const char *str, MeosType temptype, interpType interp); +extern char *tsequenceset_out(const TSequenceSet *ss, int maxdd); +extern TInstant *ttextinst_from_mfjson(json_object *mfjson); +extern TInstant *ttextinst_in(const char *str); +extern TSequence *ttextseq_from_mfjson(json_object *mfjson); +extern TSequence *ttextseq_in(const char *str, interpType interp); +extern TSequenceSet *ttextseqset_from_mfjson(json_object *mfjson); +extern TSequenceSet *ttextseqset_in(const char *str); +extern Temporal *temporal_from_mfjson(const char *mfjson, MeosType temptype); + +/*****************************************************************************/ + +/* Constructor functions for temporal types */ + +extern Temporal *temporal_from_base_temp(Datum value, MeosType temptype, const Temporal *temp); +extern TInstant *tinstant_copy(const TInstant *inst); +extern TInstant *tinstant_make(Datum value, MeosType temptype, TimestampTz t); +extern TInstant *tinstant_make_free(Datum value, MeosType temptype, TimestampTz t); +extern TSequence *tsequence_copy(const TSequence *seq); +extern TSequence *tsequence_from_base_temp(Datum value, MeosType temptype, const TSequence *seq); +extern TSequence *tsequence_from_base_tstzset(Datum value, MeosType temptype, const Set *s); +extern TSequence *tsequence_from_base_tstzspan(Datum value, MeosType temptype, const Span *s, interpType interp); +extern TSequence *tsequence_make_exp(TInstant **instants, int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *tsequence_make_free(TInstant **instants, int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequenceSet *tsequenceset_copy(const TSequenceSet *ss); +extern TSequenceSet *tseqsetarr_to_tseqset(TSequenceSet **seqsets, int count, int totalseqs); +extern TSequenceSet *tsequenceset_from_base_temp(Datum value, MeosType temptype, const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_from_base_tstzspanset(Datum value, MeosType temptype, const SpanSet *ss, interpType interp); +extern TSequenceSet *tsequenceset_make_exp(TSequence **sequences, int count, int maxcount, bool normalize); +extern TSequenceSet *tsequenceset_make_free(TSequence **sequences, int count, bool normalize); + +/*****************************************************************************/ + +/* Conversion functions for temporal types */ + +extern void temporal_set_tstzspan(const Temporal *temp, Span *s); +extern void tinstant_set_tstzspan(const TInstant *inst, Span *s); +extern void tnumber_set_tbox(const Temporal *temp, TBox *box); +extern void tnumberinst_set_tbox(const TInstant *inst, TBox *box); +extern void tnumberseq_set_tbox(const TSequence *seq, TBox *box); +extern void tnumberseqset_set_tbox(const TSequenceSet *ss, TBox *box); +extern void tsequence_set_tstzspan(const TSequence *seq, Span *s); +extern void tsequenceset_set_tstzspan(const TSequenceSet *ss, Span *s); + +/*****************************************************************************/ + +/* Accessor functions for temporal types */ + +extern const TInstant *temporal_end_inst(const Temporal *temp); +extern Datum temporal_end_value(const Temporal *temp); +extern const TInstant *temporal_inst_n(const Temporal *temp, int n); +extern const TInstant **temporal_insts_p(const Temporal *temp, int *count); +extern const TInstant *temporal_max_inst_p(const Temporal *temp); +extern Datum temporal_max_value(const Temporal *temp); +extern size_t temporal_mem_size(const Temporal *temp); +extern const TInstant *temporal_min_inst_p(const Temporal *temp); +extern Datum temporal_min_value(const Temporal *temp); +extern const TSequence **temporal_sequences_p(const Temporal *temp, int *count); +extern void temporal_set_bbox(const Temporal *temp, void *box); +extern const TInstant *temporal_start_inst(const Temporal *temp); +extern Datum temporal_start_value(const Temporal *temp); +extern Datum *temporal_values_p(const Temporal *temp, int *count); +extern bool temporal_value_n(const Temporal *temp, int n, Datum *result); +extern Datum *temporal_values(const Temporal *temp, int *count); +extern uint32 tinstant_hash(const TInstant *inst); +extern const TInstant **tinstant_insts(const TInstant *inst, int *count); +extern void tinstant_set_bbox(const TInstant *inst, void *box); +extern SpanSet *tinstant_time(const TInstant *inst); +extern TimestampTz *tinstant_timestamps(const TInstant *inst, int *count); +extern Datum tinstant_value_p(const TInstant *inst); +extern Datum tinstant_value(const TInstant *inst); +extern bool tinstant_value_at_timestamptz(const TInstant *inst, TimestampTz t, Datum *result); +extern Datum *tinstant_values_p(const TInstant *inst, int *count); +extern void tnumber_set_span(const Temporal *temp, Span *span); +extern SpanSet *tnumberinst_valuespans(const TInstant *inst); +extern double tnumberseq_avg_val(const TSequence *seq); +extern SpanSet *tnumberseq_valuespans(const TSequence *seq); +extern double tnumberseqset_avg_val(const TSequenceSet *ss); +extern SpanSet *tnumberseqset_valuespans(const TSequenceSet *ss); +extern Interval *tsequence_duration(const TSequence *seq); +extern TimestampTz tsequence_end_timestamptz(const TSequence *seq); +extern uint32 tsequence_hash(const TSequence *seq); +extern const TInstant **tsequence_insts_p(const TSequence *seq); +extern const TInstant *tsequence_max_inst_p(const TSequence *seq); +extern Datum tsequence_max_val(const TSequence *seq); +extern const TInstant *tsequence_min_inst_p(const TSequence *seq); +extern Datum tsequence_min_val(const TSequence *seq); +extern TSequence **tsequence_segments(const TSequence *seq, int *count); +extern const TSequence **tsequence_seqs(const TSequence *seq, int *count); +extern TimestampTz tsequence_start_timestamptz(const TSequence *seq); +extern SpanSet *tsequence_time(const TSequence *seq); +extern TimestampTz *tsequence_timestamps(const TSequence *seq, int *count); +extern bool tsequence_value_at_timestamptz(const TSequence *seq, TimestampTz t, bool strict, Datum *result); +extern Datum *tsequence_values_p(const TSequence *seq, int *count); +extern Interval *tsequenceset_duration(const TSequenceSet *ss, bool boundspan); +extern TimestampTz tsequenceset_end_timestamptz(const TSequenceSet *ss); +extern uint32 tsequenceset_hash(const TSequenceSet *ss); +extern const TInstant *tsequenceset_inst_n(const TSequenceSet *ss, int n); +extern const TInstant **tsequenceset_insts_p(const TSequenceSet *ss); +extern const TInstant *tsequenceset_max_inst_p(const TSequenceSet *ss); +extern Datum tsequenceset_max_val(const TSequenceSet *ss); +extern const TInstant *tsequenceset_min_inst_p(const TSequenceSet *ss); +extern Datum tsequenceset_min_val(const TSequenceSet *ss); +extern int tsequenceset_num_instants(const TSequenceSet *ss); +extern int tsequenceset_num_timestamps(const TSequenceSet *ss); +extern TSequence **tsequenceset_segments(const TSequenceSet *ss, int *count); +extern const TSequence **tsequenceset_sequences_p(const TSequenceSet *ss); +extern TimestampTz tsequenceset_start_timestamptz(const TSequenceSet *ss); +extern SpanSet *tsequenceset_time(const TSequenceSet *ss); +extern bool tsequenceset_timestamptz_n(const TSequenceSet *ss, int n, TimestampTz *result); +extern TimestampTz *tsequenceset_timestamps(const TSequenceSet *ss, int *count); +extern bool tsequenceset_value_at_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict, Datum *result); +extern bool tsequenceset_value_n(const TSequenceSet *ss, int n, Datum *result); +extern Datum *tsequenceset_values_p(const TSequenceSet *ss, int *count); + +/*****************************************************************************/ + +/* Transformation functions for temporal types */ + +extern void temporal_restart(Temporal *temp, int count); +extern TSequence *temporal_tsequence(const Temporal *temp, interpType interp); +extern TSequenceSet *temporal_tsequenceset(const Temporal *temp, interpType interp); +extern TInstant *tinstant_shift_time(const TInstant *inst, const Interval *interv); +extern TSequence *tinstant_to_tsequence(const TInstant *inst, interpType interp); +extern TSequence *tinstant_to_tsequence_free(TInstant *inst, interpType interp); +extern TSequenceSet *tinstant_to_tsequenceset(const TInstant *inst, interpType interp); +extern Temporal *tnumber_shift_scale_value(const Temporal *temp, Datum shift, Datum width, bool hasshift, bool haswidth); +extern TInstant *tnumberinst_shift_value(const TInstant *inst, Datum shift); +extern TSequence *tnumberseq_shift_scale_value(const TSequence *seq, Datum shift, Datum width, bool hasshift, bool haswidth); +extern TSequenceSet *tnumberseqset_shift_scale_value(const TSequenceSet *ss, Datum start, Datum width, bool hasshift, bool haswidth); +extern void tsequence_restart(TSequence *seq, int count); +extern Temporal *tsequence_set_interp(const TSequence *seq, interpType interp); +extern TSequence *tsequence_shift_scale_time(const TSequence *seq, const Interval *shift, const Interval *duration); +extern TSequence *tsequence_subseq(const TSequence *seq, int from, int to, bool lower_inc, bool upper_inc); +extern TInstant *tsequence_to_tinstant(const TSequence *seq); +extern TSequenceSet *tsequence_to_tsequenceset(const TSequence *seq); +extern TSequenceSet *tsequence_to_tsequenceset_free(TSequence *seq); +extern TSequenceSet *tsequence_to_tsequenceset_interp(const TSequence *seq, interpType interp); +extern void tsequenceset_restart(TSequenceSet *ss, int count); +extern Temporal *tsequenceset_set_interp(const TSequenceSet *ss, interpType interp); +extern TSequenceSet *tsequenceset_shift_scale_time(const TSequenceSet *ss, const Interval *start, const Interval *duration); +extern TSequence *tsequenceset_to_discrete(const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_to_linear(const TSequenceSet *ss); +extern TSequenceSet *tsequenceset_to_step(const TSequenceSet *ss); +extern TInstant *tsequenceset_to_tinstant(const TSequenceSet *ss); +extern TSequence *tsequenceset_to_tsequence(const TSequenceSet *ss); + +/*****************************************************************************/ + +/* Modification functions for temporal types */ + +extern Temporal *tinstant_merge(const TInstant *inst1, const TInstant *inst2); +extern Temporal *tinstant_merge_array(TInstant **instants, int count); +extern Temporal *tsequence_append_tinstant(TSequence *seq, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); +extern Temporal *tsequence_append_tsequence(const TSequence *seq1, const TSequence *seq2, bool expand); +extern Temporal *tsequence_delete_timestamptz(const TSequence *seq, TimestampTz t, bool connect); +extern Temporal *tsequence_delete_tstzset(const TSequence *seq, const Set *s, bool connect); +extern Temporal *tsequence_delete_tstzspan(const TSequence *seq, const Span *s, bool connect); +extern Temporal *tsequence_delete_tstzspanset(const TSequence *seq, const SpanSet *ss, bool connect); +extern Temporal *tsequence_insert(const TSequence *seq1, const TSequence *seq2, bool connect); +extern Temporal *tsequence_merge(const TSequence *seq1, const TSequence *seq2); +extern Temporal *tsequence_merge_array(TSequence **sequences, int count); +extern TSequenceSet *tsequenceset_append_tinstant(TSequenceSet *ss, const TInstant *inst, double maxdist, const Interval *maxt, bool expand); +extern TSequenceSet *tsequenceset_append_tsequence(TSequenceSet *ss, const TSequence *seq, bool expand); +extern TSequenceSet *tsequenceset_delete_timestamptz(const TSequenceSet *ss, TimestampTz t); +extern TSequenceSet *tsequenceset_delete_tstzset(const TSequenceSet *ss, const Set *s); +extern TSequenceSet *tsequenceset_delete_tstzspan(const TSequenceSet *ss, const Span *s); +extern TSequenceSet *tsequenceset_delete_tstzspanset(const TSequenceSet *ss, const SpanSet *ps); +extern TSequenceSet *tsequenceset_insert(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern TSequenceSet *tsequenceset_merge(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern TSequenceSet *tsequenceset_merge_array(TSequenceSet **seqsets, int count); + +/*****************************************************************************/ + +/* Bounding box functions for temporal types */ + +extern void tsequence_expand_bbox(TSequence *seq, const TInstant *inst); +extern void tsequence_set_bbox(const TSequence *seq, void *box); +extern void tsequenceset_expand_bbox(TSequenceSet *ss, const TSequence *seq); +extern void tsequenceset_set_bbox(const TSequenceSet *ss, void *box); + +/*****************************************************************************/ + +/* Restriction functions for temporal types */ + +extern TSequence *tcontseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tcontseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequenceSet *tcontseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); +extern TSequence *tdiscseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_restrict_minmax(const TSequence *seq, bool min, bool atfunc); +extern bool temporal_bbox_restrict_set(const Temporal *temp, const Set *set); +extern Temporal *temporal_restrict_minmax(const Temporal *temp, bool min, bool atfunc); +extern Temporal *temporal_restrict_timestamptz(const Temporal *temp, TimestampTz t, bool atfunc); +extern Temporal *temporal_restrict_tstzset(const Temporal *temp, const Set *s, bool atfunc); +extern Temporal *temporal_restrict_tstzspan(const Temporal *temp, const Span *s, bool atfunc); +extern Temporal *temporal_restrict_tstzspanset(const Temporal *temp, const SpanSet *ss, bool atfunc); +extern Temporal *temporal_restrict_value(const Temporal *temp, Datum value, bool atfunc); +extern Temporal *temporal_restrict_values(const Temporal *temp, const Set *set, bool atfunc); +extern bool temporal_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, Datum *result); +extern TInstant *tinstant_after_timestamptz(const TInstant *inst, TimestampTz t, bool strict); +extern TInstant *tinstant_before_timestamptz(const TInstant *inst, TimestampTz t, bool strict); +extern TInstant *tinstant_restrict_tstzspan(const TInstant *inst, const Span *period, bool atfunc); +extern TInstant *tinstant_restrict_tstzspanset(const TInstant *inst, const SpanSet *ss, bool atfunc); +extern TInstant *tinstant_restrict_timestamptz(const TInstant *inst, TimestampTz t, bool atfunc); +extern TInstant *tinstant_restrict_tstzset(const TInstant *inst, const Set *s, bool atfunc); +extern TInstant *tinstant_restrict_value(const TInstant *inst, Datum value, bool atfunc); +extern TInstant *tinstant_restrict_values(const TInstant *inst, const Set *set, bool atfunc); +extern Temporal *tnumber_restrict_span(const Temporal *temp, const Span *span, bool atfunc); +extern Temporal *tnumber_restrict_spanset(const Temporal *temp, const SpanSet *ss, bool atfunc); +extern TInstant *tnumberinst_restrict_span(const TInstant *inst, const Span *span, bool atfunc); +extern TInstant *tnumberinst_restrict_spanset(const TInstant *inst, const SpanSet *ss, bool atfunc); +extern TSequenceSet *tnumberseqset_restrict_span(const TSequenceSet *ss, const Span *span, bool atfunc); +extern TSequenceSet *tnumberseqset_restrict_spanset(const TSequenceSet *ss, const SpanSet *spanset, bool atfunc); +extern TInstant *tsequence_at_timestamptz(const TSequence *seq, TimestampTz t); +extern Temporal *tsequence_restrict_tstzspan(const TSequence *seq, const Span *s, bool atfunc); +extern Temporal *tsequence_restrict_tstzspanset(const TSequence *seq, const SpanSet *ss, bool atfunc); +extern TSequenceSet *tsequenceset_after_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict); +extern TSequenceSet *tsequenceset_before_timestamptz(const TSequenceSet *ss, TimestampTz t, bool strict); +extern TSequenceSet *tsequenceset_restrict_minmax(const TSequenceSet *ss, bool min, bool atfunc); +extern TSequenceSet *tsequenceset_restrict_tstzspan(const TSequenceSet *ss, const Span *s, bool atfunc); +extern TSequenceSet *tsequenceset_restrict_tstzspanset(const TSequenceSet *ss, const SpanSet *ps, bool atfunc); +extern Temporal *tsequenceset_restrict_timestamptz(const TSequenceSet *ss, TimestampTz t, bool atfunc); +extern Temporal *tsequenceset_restrict_tstzset(const TSequenceSet *ss, const Set *s, bool atfunc); +extern TSequenceSet *tsequenceset_restrict_value(const TSequenceSet *ss, Datum value, bool atfunc); +extern TSequenceSet *tsequenceset_restrict_values(const TSequenceSet *ss, const Set *s, bool atfunc); + +/*****************************************************************************/ + +/* Traditional comparison functions for temporal types */ + +extern int tinstant_cmp(const TInstant *inst1, const TInstant *inst2); +extern bool tinstant_eq(const TInstant *inst1, const TInstant *inst2); +extern int tsequence_cmp(const TSequence *seq1, const TSequence *seq2); +extern bool tsequence_eq(const TSequence *seq1, const TSequence *seq2); +extern int tsequenceset_cmp(const TSequenceSet *ss1, const TSequenceSet *ss2); +extern bool tsequenceset_eq(const TSequenceSet *ss1, const TSequenceSet *ss2); + +/*****************************************************************************/ + +/* Ever/always functions for temporal types */ + +extern int always_eq_base_temporal(Datum value, const Temporal *temp); +extern int always_eq_temporal_base(const Temporal *temp, Datum value); +extern int always_ne_base_temporal(Datum value, const Temporal *temp); +extern int always_ne_temporal_base(const Temporal *temp, Datum value); +extern int always_ge_base_temporal(Datum value, const Temporal *temp); +extern int always_ge_temporal_base(const Temporal *temp, Datum value); +extern int always_gt_base_temporal(Datum value, const Temporal *temp); +extern int always_gt_temporal_base(const Temporal *temp, Datum value); +extern int always_le_base_temporal(Datum value, const Temporal *temp); +extern int always_le_temporal_base(const Temporal *temp, Datum value); +extern int always_lt_base_temporal(Datum value, const Temporal *temp); +extern int always_lt_temporal_base(const Temporal *temp, Datum value); +extern int ever_eq_base_temporal(Datum value, const Temporal *temp); +extern int ever_eq_temporal_base(const Temporal *temp, Datum value); +extern int ever_ne_base_temporal(Datum value, const Temporal *temp); +extern int ever_ne_temporal_base(const Temporal *temp, Datum value); +extern int ever_ge_base_temporal(Datum value, const Temporal *temp); +extern int ever_ge_temporal_base(const Temporal *temp, Datum value); +extern int ever_gt_base_temporal(Datum value, const Temporal *temp); +extern int ever_gt_temporal_base(const Temporal *temp, Datum value); +extern int ever_le_base_temporal(Datum value, const Temporal *temp); +extern int ever_le_temporal_base(const Temporal *temp, Datum value); +extern int ever_lt_base_temporal(Datum value, const Temporal *temp); +extern int ever_lt_temporal_base(const Temporal *temp, Datum value); + +/*****************************************************************************/ + +/* Mathematical functions for temporal types */ + +extern TInstant *tnumberinst_abs(const TInstant *inst); +extern TSequence *tnumberseq_abs(const TSequence *seq); +extern TSequence *tnumberseq_angular_difference(const TSequence *seq); +extern TSequence *tnumberseq_delta_value(const TSequence *seq); +extern TSequenceSet *tnumberseqset_abs(const TSequenceSet *ss); +extern TSequence *tnumberseqset_angular_difference(const TSequenceSet *ss); +extern TSequenceSet *tnumberseqset_delta_value(const TSequenceSet *ss); + +/*****************************************************************************/ + +/* Distance functions for temporal types */ + +extern double distance_span_span_double(const Span *s1, const Span *s2); +extern double nad_tbox_tbox(const TBox *box1, const TBox *box2); +extern double nad_tnumber_number(const Temporal *temp, Datum value); +extern double nad_tnumber_tbox(const Temporal *temp, const TBox *box); +extern double nad_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdistance_tnumber_number(const Temporal *temp, Datum value); +extern double tnumberinst_distance(const TInstant *inst1, const TInstant *inst2); + +/*****************************************************************************/ + +/* Local aggregate functions for temporal types */ + +extern double tnumberseq_integral(const TSequence *seq); +extern double tnumberseq_twavg(const TSequence *seq); +extern double tnumberseqset_integral(const TSequenceSet *ss); +extern double tnumberseqset_twavg(const TSequenceSet *ss); + +/*****************************************************************************/ + +/* Compact functions for final append aggregate */ + +extern Temporal *temporal_compact(const Temporal *temp); +extern TSequence *tsequence_compact(const TSequence *seq); +extern TSequenceSet *tsequenceset_compact(const TSequenceSet *ss); + +/*****************************************************************************/ + +/* Aggregate functions for temporal types */ + +extern SkipList *temporal_skiplist_make(); +extern SkipList *skiplist_make(size_t key_size, size_t value_size, + int (*comp_fn)(void *, void *), void *(*merge_fn)(void *, void *)); +extern int skiplist_search(SkipList *list, void *key, void *value); +extern void skiplist_free(SkipList *list); +extern void skiplist_splice(SkipList *list, void **keys, void **values, int count, datum_func2 func, bool crossings, SkipListType sktype); +extern void temporal_skiplist_splice(SkipList *list, void **values, int count, datum_func2 func, bool crossings); +extern void **skiplist_values(SkipList *list); +extern void **skiplist_keys_values(SkipList *list, void **values); + +extern Temporal *temporal_app_tinst_transfn(Temporal *state, const TInstant *inst, interpType interp, double maxdist, const Interval *maxt); +extern Temporal *temporal_app_tseq_transfn(Temporal *state, const TSequence *seq); + +/*****************************************************************************/ + +/* Tile functions for span and temporal types */ + +extern Span *span_bins(const Span *s, Datum size, Datum origin, int *count); +extern Span *spanset_bins(const SpanSet *ss, Datum size, Datum origin, int *count); +extern Span *tnumber_value_bins(const Temporal *temp, Datum size, Datum origin, int *count); +extern TBox *tnumber_value_time_boxes(const Temporal *temp, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, int *count); +extern Temporal **tnumber_value_split(const Temporal *temp, Datum vsize, Datum vorigin, Datum **bins, int *count); +extern TBox *tbox_get_value_time_tile(Datum value, TimestampTz t, Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, MeosType basetype, MeosType spantype); +extern Temporal **tnumber_value_time_split(const Temporal *temp, Datum size, const Interval *duration, Datum vorigin, TimestampTz torigin, Datum **value_bins, TimestampTz **time_bins, int *count); + +/*****************************************************************************/ + +/* Similarity functions for temporal types */ + + +/*****************************************************************************/ + +#endif /* __MEOS_INTERNAL_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal_geo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal_geo.h new file mode 100644 index 0000000..e959554 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_internal_geo.h @@ -0,0 +1,303 @@ +/***************************************************************************** + * + * This MobilityDB code seq provided under The PostgreSQL License. + * Copyright(c) 2016-2023, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License(GPLv2 or later). + * Copyright(c) 2001-2023, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement seq hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Internal API of the Mobility Engine Open Source(MEOS) library. + */ + +#ifndef __MEOS_INTERNAL_GEO_H__ +#define __MEOS_INTERNAL_GEO_H__ + +/* C */ +#include +/* JSON-C */ +#include +/* PROJ */ +#include +/* PostgreSQL */ +/* MEOS */ +#include +#include +#include + +/***************************************************************************** + * Direct access to a single point in the GSERIALIZED struct + *****************************************************************************/ + +/* + * Obtain a geometry/geography point from the GSERIALIZED WITHOUT creating + * the corresponding LWGEOM. These functions constitute a **SERIOUS** + * break of encapsulation but it is the only way to achieve reasonable + * performance when manipulating mobility data. + * The datum_* functions suppose that the GSERIALIZED has been already + * detoasted. This is typically the case when the datum is within a Temporal* + * that has been already detoasted with PG_GETARG_TEMPORAL* + * The first variant (e.g. datum_point2d) is slower than the second (e.g. + * datum_point2d_p) since the point is passed by value and thus the bytes + * are copied. The second version is declared const because you aren't allowed + * to modify the values, only read them. + */ + +/** + * @brief Macro for accessing the GSERIALIZED value of a temporal point. + * @pre It is assumed that the geometry/geography IS NOT TOASTED + */ +#define DatumGetGserializedP(X) ((GSERIALIZED *) DatumGetPointer(X)) +#define GserializedPGetDatum(X) PointerGetDatum(X) + +/** + * @brief Definition for the internal aspects of the GSERIALIZED struct + */ +// #define LWFLAG_EXTFLAGS 0x20 +#define LWFLAG_VERSBIT2 0x80 + +// #define FLAGS_GET_EXTFLAGS(flags) (((flags) & LWFLAG_EXTFLAGS)>>5) +#define FLAGS_GET_VERSBIT2(flags) (((flags) & LWFLAG_VERSBIT2)>>7) + +#define GS_POINT_PTR(gs) ( (uint8_t *) ((gs)->data) + 8 + \ + FLAGS_GET_BBOX((gs)->gflags) * FLAGS_NDIMS_BOX((gs)->gflags) * 8 + \ + FLAGS_GET_VERSBIT2((gs)->gflags) * 8 ) + +/** + * @brief Return a pointer to a 2D/3DZ point from the datum/GSERIALIZED + */ +#define DATUM_POINT2D_P(gs) ( (POINT2D *) GS_POINT_PTR(DatumGetGserializedP(gs)) ) +#define DATUM_POINT3DZ_P(gs) ( (POINT3DZ *) GS_POINT_PTR(DatumGetGserializedP(gs)) ) + +#define GSERIALIZED_POINT2D_P(gs) ( (POINT2D *) GS_POINT_PTR((gs)) ) +#define GSERIALIZED_POINT3DZ_P(gs) ( (POINT3DZ *) GS_POINT_PTR((gs)) ) + +/***************************************************************************** + * Internal function accessing the PROJ library + *****************************************************************************/ + +extern PJ_CONTEXT *proj_get_context(void); + +/***************************************************************************** + * Round functions + *****************************************************************************/ + +extern Datum datum_geo_round(Datum value, Datum size); +extern GSERIALIZED *point_round(const GSERIALIZED *gs, int maxdd); + +/****************************************************************************** + * Functions for box types + *****************************************************************************/ + +/* Constructor functions for box types */ + +extern void stbox_set(bool hasx, bool hasz, bool geodetic, int32 srid, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, const Span *s, STBox *box); + +/*****************************************************************************/ + +/* Conversion functions for box types */ + +extern void gbox_set_stbox(const GBOX *box, int32_t srid, STBox *result); +extern bool geo_set_stbox(const GSERIALIZED *gs, STBox *box); +extern void geoarr_set_stbox(const Datum *values, int count, STBox *box); +extern bool spatial_set_stbox(Datum d, MeosType basetype, STBox *box); +extern void spatialset_set_stbox(const Set *set, STBox *box); +extern void stbox_set_box3d(const STBox *box, BOX3D *box3d); +extern void stbox_set_gbox(const STBox *box, GBOX *gbox); +extern void tstzset_set_stbox(const Set *s, STBox *box); +extern void tstzspan_set_stbox(const Span *s, STBox *box); +extern void tstzspanset_set_stbox(const SpanSet *s, STBox *box); + +/*****************************************************************************/ + +/* Transformation functions for box types */ + +extern void stbox_expand(const STBox *box1, STBox *box2); + +/*****************************************************************************/ + +/* Set functions for box types */ + +extern bool inter_stbox_stbox(const STBox *box1, const STBox *box2, STBox *result); +extern GSERIALIZED *stbox_geo(const STBox *box); + +/***************************************************************************** + * Functions for temporal types + *****************************************************************************/ + +/* Input and output functions */ + +extern TInstant *tgeogpointinst_from_mfjson(json_object *mfjson, int32_t srid); +extern TInstant *tgeogpointinst_in(const char *str); +extern TSequence *tgeogpointseq_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequence *tgeogpointseq_in(const char *str, interpType interp); +extern TSequenceSet *tgeogpointseqset_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequenceSet *tgeogpointseqset_in(const char *str); +extern TInstant *tgeompointinst_from_mfjson(json_object *mfjson, int32_t srid); +extern TInstant *tgeompointinst_in(const char *str); +extern TSequence *tgeompointseq_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequence *tgeompointseq_in(const char *str, interpType interp); +extern TSequenceSet *tgeompointseqset_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequenceSet *tgeompointseqset_in(const char *str); +extern TInstant *tgeographyinst_from_mfjson(json_object *mfjson, int32_t srid); +extern TInstant *tgeographyinst_in(const char *str); +extern TSequence *tgeographyseq_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequence *tgeographyseq_in(const char *str, interpType interp); +extern TSequenceSet *tgeographyseqset_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequenceSet *tgeographyseqset_in(const char *str); +extern TInstant *tgeometryinst_from_mfjson(json_object *mfjson, int32_t srid); +extern TInstant *tgeometryinst_in(const char *str); +extern TSequence *tgeometryseq_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequence *tgeometryseq_in(const char *str, interpType interp); +extern TSequenceSet *tgeometryseqset_from_mfjson(json_object *mfjson, int32_t srid, interpType interp); +extern TSequenceSet *tgeometryseqset_in(const char *str); + +/*****************************************************************************/ + +/* Constructor functions */ + +/*****************************************************************************/ + +/* Conversion functions */ + +/*****************************************************************************/ + +/* Accessor functions */ + +/*****************************************************************************/ + +/* Transformation functions */ + +/*****************************************************************************/ + +/* Modification functions */ + +/*****************************************************************************/ + +/* Bounding box functions */ + +extern void tspatial_set_stbox(const Temporal *temp, STBox *box); +extern void tgeoinst_set_stbox(const TInstant *inst, STBox *box); +extern void tspatialseq_set_stbox(const TSequence *seq, STBox *box); +extern void tspatialseqset_set_stbox(const TSequenceSet *ss, STBox *box); + +/*****************************************************************************/ + +/* Restriction functions */ + +extern Temporal *tgeo_restrict_elevation(const Temporal *temp, const Span *s, bool atfunc); +extern Temporal *tgeo_restrict_geom(const Temporal *temp, const GSERIALIZED *gs, bool atfunc); +extern Temporal *tgeo_restrict_stbox(const Temporal *temp, const STBox *box, bool border_inc, bool atfunc); +extern TInstant *tgeoinst_restrict_geom(const TInstant *inst, const GSERIALIZED *gs, bool atfunc); +extern TInstant *tgeoinst_restrict_stbox(const TInstant *inst, const STBox *box, bool border_inc, bool atfunc); +extern Temporal *tgeoseq_restrict_geom(const TSequence *seq, const GSERIALIZED *gs, bool atfunc); +extern Temporal *tgeoseq_restrict_stbox(const TSequence *seq, const STBox *box, bool border_inc, bool atfunc); +extern TSequenceSet *tgeoseqset_restrict_geom(const TSequenceSet *ss, const GSERIALIZED *gs, bool atfunc); +extern TSequenceSet *tgeoseqset_restrict_stbox(const TSequenceSet *ss, const STBox *box, bool border_inc, bool atfunc); + +/*****************************************************************************/ + +/* Traditional comparison functions */ + +/*****************************************************************************/ + +/* Ever/always functions */ + +/*****************************************************************************/ + +/* Mathematical functions */ + +/*****************************************************************************/ + +/* Distance functions */ + +/***************************************************************************** + * Spatial functions for temporal points + *****************************************************************************/ + +/* Spatial accessor functions for temporal points */ + +extern int32_t spatial_srid(Datum d, MeosType basetype); +extern bool spatial_set_srid(Datum d, MeosType basetype, int32_t srid); +extern int tspatialinst_srid(const TInstant *inst); +extern TSequenceSet *tpointseq_azimuth(const TSequence *seq); +extern TSequence *tpointseq_cumulative_length(const TSequence *seq, double prevlength); +extern bool tpointseq_is_simple(const TSequence *seq); +extern double tpointseq_length(const TSequence *seq); +extern GSERIALIZED *tpointseq_linear_trajectory(const TSequence *seq, bool unary_union); +extern STBox *tgeoseq_stboxes(const TSequence *seq, int *count); +extern STBox *tgeoseq_split_n_stboxes(const TSequence *seq, int max_count, int *count); +extern TSequenceSet *tpointseqset_azimuth(const TSequenceSet *ss); +extern TSequenceSet *tpointseqset_cumulative_length(const TSequenceSet *ss); +extern bool tpointseqset_is_simple(const TSequenceSet *ss); +extern double tpointseqset_length(const TSequenceSet *ss); +extern STBox *tgeoseqset_stboxes(const TSequenceSet *ss, int *count); +extern STBox *tgeoseqset_split_n_stboxes(const TSequenceSet *ss, int max_count, int *count); +extern Temporal *tpoint_get_coord(const Temporal *temp, int coord); + +/*****************************************************************************/ + +/* Spatial transformation functions for temporal points */ + +extern TInstant *tgeominst_tgeoginst(const TInstant *inst, bool oper); +extern TSequence *tgeomseq_tgeogseq(const TSequence *seq, bool oper); +extern TSequenceSet *tgeomseqset_tgeogseqset(const TSequenceSet *ss, bool oper); +extern Temporal *tgeom_tgeog(const Temporal *temp, bool oper); +extern Temporal *tgeo_tpoint(const Temporal *temp, bool oper); +extern void tspatialinst_set_srid(TInstant *inst, int32_t srid); +extern TSequence **tpointseq_make_simple(const TSequence *seq, int *count); +extern void tspatialseq_set_srid(TSequence *seq, int32_t srid); +extern TSequence **tpointseqset_make_simple(const TSequenceSet *ss, int *count); +extern void tspatialseqset_set_srid(TSequenceSet *ss, int32_t srid); + +/*****************************************************************************/ + +/* Local aggregate functions */ + +extern GSERIALIZED *tpointseq_twcentroid(const TSequence *seq); +extern GSERIALIZED *tpointseqset_twcentroid(const TSequenceSet *ss); + +/*****************************************************************************/ + +/* Compact functions for final append aggregate */ + + +/*****************************************************************************/ + +/* Aggregate functions */ + + +/*****************************************************************************/ + +/* Tile functions for span and temporal types */ + + +/*****************************************************************************/ + +/* Similarity functions */ + + +/*****************************************************************************/ + +#endif /* __MEOS_INTERNAL_GEO_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_npoint.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_npoint.h new file mode 100644 index 0000000..6983524 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_npoint.h @@ -0,0 +1,330 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief API of the Mobility Engine Open Source (MEOS) library. + */ + +#ifndef __MEOS_NPOINT_H__ +#define __MEOS_NPOINT_H__ + +/* C */ +#include +#include +/* MEOS */ +#include +#include +#include + +/***************************************************************************** + * Type definitions + *****************************************************************************/ + +/* Structure to represent network-based points */ + +typedef struct +{ + int64 rid; /**< route identifier */ + double pos; /**< position */ +} Npoint; + +/* Structure to represent network-based segments */ + +typedef struct +{ + int64 rid; /**< route identifier */ + double pos1; /**< position1 */ + double pos2; /**< position2 */ +} Nsegment; + +/***************************************************************************** + * Validity macros and functions + *****************************************************************************/ + +/** + * @brief Macro for ensuring that the set passed as argument is a network + * point set + */ +#if MEOS + #define VALIDATE_NPOINTSET(set, ret) \ + do { \ + if (! ensure_not_null((void *) (set)) || \ + ! ensure_set_isof_type((set), T_NPOINTSET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_NPOINTSET(set, ret) \ + do { \ + assert(set); \ + assert(set->settype == T_NPOINTSET); \ + } while (0) +#endif /* MEOS */ + +/** + * @brief Macro for ensuring that the temporal value passed as argument is a + * temporal network point + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TNPOINT(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TNPOINT) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TNPOINT(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TNPOINT); \ + } while (0) +#endif /* MEOS */ + +/****************************************************************************** + * Functions for network points + ******************************************************************************/ + +/* Input and output functions */ + +extern char *npoint_as_ewkt(const Npoint *np, int maxdd); +extern char *npoint_as_hexwkb(const Npoint *np, uint8_t variant, size_t *size_out); +extern char *npoint_as_text(const Npoint *np, int maxdd); +extern uint8_t *npoint_as_wkb(const Npoint *np, uint8_t variant, size_t *size_out); +extern Npoint *npoint_from_hexwkb(const char *hexwkb); +extern Npoint *npoint_from_wkb(const uint8_t *wkb, size_t size); +extern Npoint *npoint_in(const char *str); +extern char *npoint_out(const Npoint *np, int maxdd); +extern Nsegment *nsegment_in(const char *str); +extern char *nsegment_out(const Nsegment *ns, int maxdd); + +/* Constructor functions */ + +extern Npoint *npoint_make(int64 rid, double pos); +extern Nsegment *nsegment_make(int64 rid, double pos1, double pos2); + +/* Conversion functions */ + +extern Npoint *geompoint_to_npoint(const GSERIALIZED *gs); +extern Nsegment *geom_to_nsegment(const GSERIALIZED *gs); +extern GSERIALIZED *npoint_to_geompoint(const Npoint *np); +extern Nsegment *npoint_to_nsegment(const Npoint *np); +extern STBox *npoint_to_stbox(const Npoint *np); +extern GSERIALIZED *nsegment_to_geom(const Nsegment *ns); +extern STBox *nsegment_to_stbox(const Nsegment *np); + +/* Accessor functions */ + +extern uint32 npoint_hash(const Npoint *np); +extern uint64 npoint_hash_extended(const Npoint *np, uint64 seed); +extern double npoint_position(const Npoint *np); +extern int64 npoint_route(const Npoint *np); +extern double nsegment_end_position(const Nsegment *ns); +extern int64 nsegment_route(const Nsegment *ns); +extern double nsegment_start_position(const Nsegment *ns); + +/* Route functions */ + +extern bool route_exists(int64 rid); +extern const GSERIALIZED *route_geom(int64 rid); +extern double route_length(int64 rid); + +/* Transformation functions */ + +extern Npoint *npoint_round(const Npoint *np, int maxdd); +extern Nsegment *nsegment_round(const Nsegment *ns, int maxdd); + +/* Spatial reference system functions */ + +extern int32_t get_srid_ways(void); +extern int32_t npoint_srid(const Npoint *np); +extern int32_t nsegment_srid(const Nsegment *ns); + +/* Bounding box functions */ + +extern STBox *npoint_timestamptz_to_stbox(const Npoint *np, TimestampTz t); +extern STBox *npoint_tstzspan_to_stbox(const Npoint *np, const Span *s); + +/* Comparison functions */ + +extern int npoint_cmp(const Npoint *np1, const Npoint *np2); +extern bool npoint_eq(const Npoint *np1, const Npoint *np2); +extern bool npoint_ge(const Npoint *np1, const Npoint *np2); +extern bool npoint_gt(const Npoint *np1, const Npoint *np2); +extern bool npoint_le(const Npoint *np1, const Npoint *np2); +extern bool npoint_lt(const Npoint *np1, const Npoint *np2); +extern bool npoint_ne(const Npoint *np1, const Npoint *np2); +extern bool npoint_same(const Npoint *np1, const Npoint *np2); +extern int nsegment_cmp(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_eq(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_ge(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_gt(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_le(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_lt(const Nsegment *ns1, const Nsegment *ns2); +extern bool nsegment_ne(const Nsegment *ns1, const Nsegment *ns2); + +/****************************************************************************** + * Functions for network point sets + ******************************************************************************/ + +/* Input and output functions */ + +extern Set *npointset_in(const char *str); +extern char *npointset_out(const Set *s, int maxdd); + +/* Constructor functions */ + +extern Set *npointset_make(Npoint **values, int count); + +/* Conversion functions */ + +extern Set *npoint_to_set(const Npoint *np); + +/* Accessor functions */ + +extern Npoint *npointset_end_value(const Set *s); +extern Set *npointset_routes(const Set *s); +extern Npoint *npointset_start_value(const Set *s); +extern bool npointset_value_n(const Set *s, int n, Npoint **result); +extern Npoint **npointset_values(const Set *s); + +/* Set operations */ + +extern bool contained_npoint_set(const Npoint *np, const Set *s); +extern bool contains_set_npoint(const Set *s, const Npoint *np); +extern Set *intersection_npoint_set(const Npoint *np, const Set *s); +extern Set *intersection_set_npoint(const Set *s, const Npoint *np); +extern Set *minus_npoint_set(const Npoint *np, const Set *s); +extern Set *minus_set_npoint(const Set *s, const Npoint *np); +extern Set *npoint_union_transfn(Set *state, const Npoint *np); +extern Set *union_npoint_set(const Npoint *np, const Set *s); +extern Set *union_set_npoint(const Set *s, const Npoint *np); + +/*===========================================================================* + * Functions for temporal network points + *===========================================================================*/ + +/***************************************************************************** + * Input/output functions + *****************************************************************************/ + +extern Temporal *tnpoint_in(const char *str); +extern Temporal *tnpoint_from_mfjson(const char *mfjson); +extern char *tnpoint_out(const Temporal *temp, int maxdd); + +/***************************************************************************** + * Constructor functions + *****************************************************************************/ + +extern TInstant *tnpointinst_make(const Npoint *np, TimestampTz t); + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +extern Temporal *tgeompoint_to_tnpoint(const Temporal *temp); +extern Temporal *tnpoint_to_tgeompoint(const Temporal *temp); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +extern Temporal *tnpoint_cumulative_length(const Temporal *temp); +extern double tnpoint_length(const Temporal *temp); +extern Nsegment **tnpoint_positions(const Temporal *temp, int *count); +extern int64 tnpoint_route(const Temporal *temp); +extern Set *tnpoint_routes(const Temporal *temp); +extern Temporal *tnpoint_speed(const Temporal *temp); +extern GSERIALIZED *tnpoint_trajectory(const Temporal *temp); +extern GSERIALIZED *tnpoint_twcentroid(const Temporal *temp); + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +extern Temporal *tnpoint_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tnpoint_at_npoint(const Temporal *temp, const Npoint *np); +extern Temporal *tnpoint_at_npointset(const Temporal *temp, const Set *s); +extern Temporal *tnpoint_at_stbox(const Temporal *temp, const STBox *box, bool border_inc); +extern Temporal *tnpoint_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tnpoint_minus_npoint(const Temporal *temp, const Npoint *np); +extern Temporal *tnpoint_minus_npointset(const Temporal *temp, const Set *s); +extern Temporal *tnpoint_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +extern Temporal *tdistance_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern Temporal *tdistance_tnpoint_point(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdistance_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern double nad_tnpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern double nad_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern double nad_tnpoint_stbox(const Temporal *temp, const STBox *box); +extern double nad_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_tnpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern TInstant *nai_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern TInstant *nai_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_tnpoint_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern GSERIALIZED *shortestline_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Aggregate functions + *****************************************************************************/ + +extern SkipList *tnpoint_tcentroid_transfn(SkipList *state, Temporal *temp); + +/***************************************************************************** + * Comparison functions + *****************************************************************************/ + +/* Ever/always comparisons */ + +extern int always_eq_npoint_tnpoint(const Npoint *np, const Temporal *temp); +extern int always_eq_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern int always_eq_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_npoint_tnpoint(const Npoint *np, const Temporal *temp); +extern int always_ne_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern int always_ne_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_npoint_tnpoint(const Npoint *np, const Temporal *temp); +extern int ever_eq_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern int ever_eq_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_npoint_tnpoint(const Npoint *np, const Temporal *temp); +extern int ever_ne_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern int ever_ne_tnpoint_tnpoint(const Temporal *temp1, const Temporal *temp2); + +/* Temporal comparisons */ + +extern Temporal *teq_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern Temporal *tne_tnpoint_npoint(const Temporal *temp, const Npoint *np); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_pose.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_pose.h new file mode 100644 index 0000000..c9709ce --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_pose.h @@ -0,0 +1,305 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief External API of the Mobility Engine Open Source (MEOS) library + */ + +#ifndef __MEOS_POSE_H__ +#define __MEOS_POSE_H__ + +/* C */ +#include +#include +/* MEOS */ +#include +#include + +/***************************************************************************** + * Struct definitions + *****************************************************************************/ + +/** + * Opaque structure to represent pose values + */ +typedef struct Pose Pose; + +/***************************************************************************** + * Validity macros + *****************************************************************************/ + +/** + * @brief Macro for ensuring that the set passed as argument is a pose set + */ +#if MEOS + #define VALIDATE_POSESET(set, ret) \ + do { \ + if (! ensure_not_null((void *) set) || \ + ! ensure_set_isof_type((set), T_POSESET) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_POSESET(set, ret) \ + do { \ + assert(set); \ + assert((set)->settype == T_POSESET); \ + } while (0) +#endif + +/** + * @brief Macro for ensuring that the temporal value passed as argument is a + * temporal pose + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TPOSE(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TPOSE) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TPOSE(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TPOSE); \ + } while (0) +#endif + +/****************************************************************************** + * Functions for poses + ******************************************************************************/ + +/* Input and output functions */ + +extern char *pose_as_ewkt(const Pose *pose, int maxdd); +extern char *pose_as_hexwkb(const Pose *pose, uint8_t variant, size_t *size); +extern char *pose_as_text(const Pose *pose, int maxdd); +extern uint8_t *pose_as_wkb(const Pose *pose, uint8_t variant, size_t *size_out); +extern Pose *pose_from_wkb(const uint8_t *wkb, size_t size); +extern Pose *pose_from_hexwkb(const char *hexwkb); +extern Pose *pose_in(const char *str); +extern char *pose_out(const Pose *pose, int maxdd); + +/* Constructor functions */ + +extern Pose *pose_copy(const Pose *pose); +extern Pose *pose_make_2d(double x, double y, double theta, int32_t srid); +extern Pose *pose_make_3d(double x, double y, double z, double W, double X, double Y, double Z, int32_t srid); +extern Pose *pose_make_point2d(const GSERIALIZED *gs, double theta); +extern Pose *pose_make_point3d(const GSERIALIZED *gs, double W, double X, double Y, double Z); + +/* Conversion functions */ + +extern GSERIALIZED *pose_to_point(const Pose *pose); +extern STBox *pose_to_stbox(const Pose *pose); + +/* Accessor functions */ + +extern uint32 pose_hash(const Pose *pose); +extern uint64 pose_hash_extended(const Pose *pose, uint64 seed); +extern double *pose_orientation(const Pose *pose); +extern double pose_rotation(const Pose *pose); + +/* Transformation functions */ + +extern Pose *pose_round(const Pose *pose, int maxdd); +extern Pose **posearr_round(const Pose **posearr, int count, int maxdd); + +/* Spatial reference system functions */ + +extern void pose_set_srid(Pose *pose, int32_t srid); +extern int32_t pose_srid(const Pose *pose); +extern Pose *pose_transform(const Pose *pose, int32_t srid); +extern Pose *pose_transform_pipeline(const Pose *pose, const char *pipelinestr, int32_t srid, bool is_forward); + +/* Bounding box functions */ + +extern STBox *pose_tstzspan_to_stbox(const Pose *pose, const Span *s); +extern STBox *pose_timestamptz_to_stbox(const Pose *pose, TimestampTz t); + +/* Distance functions */ + +extern double distance_pose_geo(const Pose *pose, const GSERIALIZED *gs); +extern double distance_pose_pose(const Pose *pose1, const Pose *pose2); +extern double distance_pose_stbox(const Pose *pose, const STBox *box); + +/* Comparison functions */ + +extern int pose_cmp(const Pose *pose1, const Pose *pose2); +extern bool pose_eq(const Pose *pose1, const Pose *pose2); +extern bool pose_ge(const Pose *pose1, const Pose *pose2); +extern bool pose_gt(const Pose *pose1, const Pose *pose2); +extern bool pose_le(const Pose *pose1, const Pose *pose2); +extern bool pose_lt(const Pose *pose1, const Pose *pose2); +extern bool pose_ne(const Pose *pose1, const Pose *pose2); +extern bool pose_nsame(const Pose *pose1, const Pose *pose2); +extern bool pose_same(const Pose *pose1, const Pose *pose2); + +/****************************************************************************** + * Functions for pose sets + ******************************************************************************/ + +/* Input and output functions */ + +extern Set *poseset_in(const char *str); +extern char *poseset_out(const Set *s, int maxdd); + +/* Constructor functions */ + +extern Set *poseset_make(const Pose **values, int count); + +/* Conversion functions */ + +extern Set *pose_to_set(const Pose *pose); + +/* Accessor functions */ + +extern Pose *poseset_end_value(const Set *s); +extern Pose *poseset_start_value(const Set *s); +extern bool poseset_value_n(const Set *s, int n, Pose **result); +extern Pose **poseset_values(const Set *s); + +/* Set operations */ + +extern bool contained_pose_set(const Pose *pose, const Set *s); +extern bool contains_set_pose(const Set *s, Pose *pose); +extern Set *intersection_pose_set(const Pose *pose, const Set *s); +extern Set *intersection_set_pose(const Set *s, const Pose *pose); +extern Set *minus_pose_set(const Pose *pose, const Set *s); +extern Set *minus_set_pose(const Set *s, const Pose *pose); +extern Set *pose_union_transfn(Set *state, const Pose *pose); +extern Set *union_pose_set(const Pose *pose, const Set *s); +extern Set *union_set_pose(const Set *s, const Pose *pose); + +/*===========================================================================* + * Functions for temporal poses + *===========================================================================*/ + +/***************************************************************************** + * Input/output functions + *****************************************************************************/ + +Temporal *tpose_in(const char *str); + +/***************************************************************************** + * Constructor functions + *****************************************************************************/ + + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +extern Temporal *tpose_make(const Temporal *tpoint, const Temporal *tradius); +extern Temporal *tpose_to_tpoint(const Temporal *temp); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +extern Pose *tpose_end_value(const Temporal *temp); +extern Set *tpose_points(const Temporal *temp); +// extern Temporal *tpose_orientation(const Temporal *temp); +extern Temporal *tpose_rotation(const Temporal *temp); +extern Pose *tpose_start_value(const Temporal *temp); +extern GSERIALIZED *tpose_trajectory(const Temporal *temp); +extern bool tpose_value_at_timestamptz(const Temporal *temp, TimestampTz t, bool strict, Pose **value); +extern bool tpose_value_n(const Temporal *temp, int n, Pose **result); +extern Pose **tpose_values(const Temporal *temp, int *count); + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +extern Temporal *tpose_at_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpose_at_stbox(const Temporal *temp, const STBox *box, bool border_inc); +extern Temporal *tpose_at_pose(const Temporal *temp, const Pose *pose); +extern Temporal *tpose_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tpose_minus_pose(const Temporal *temp, const Pose *pose); +extern Temporal *tpose_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +extern Temporal *tdistance_tpose_pose(const Temporal *temp, const Pose *pose); +extern Temporal *tdistance_tpose_point(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdistance_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern double nad_tpose_geo(const Temporal *temp, const GSERIALIZED *gs); +extern double nad_tpose_pose(const Temporal *temp, const Pose *pose); +extern double nad_tpose_stbox(const Temporal *temp, const STBox *box); +extern double nad_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_tpose_geo(const Temporal *temp, const GSERIALIZED *gs); +extern TInstant *nai_tpose_pose(const Temporal *temp, const Pose *pose); +extern TInstant *nai_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_tpose_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_tpose_pose(const Temporal *temp, const Pose *pose); +extern GSERIALIZED *shortestline_tpose_tpose(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Comparison functions + *****************************************************************************/ + +/* Ever/always and temporal comparison functions */ + +extern int always_eq_pose_tpose(const Pose *pose, const Temporal *temp); +extern int always_eq_tpose_pose(const Temporal *temp, const Pose *pose); +extern int always_eq_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_pose_tpose(const Pose *pose, const Temporal *temp); +extern int always_ne_tpose_pose(const Temporal *temp, const Pose *pose); +extern int always_ne_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_pose_tpose(const Pose *pose, const Temporal *temp); +extern int ever_eq_tpose_pose(const Temporal *temp, const Pose *pose); +extern int ever_eq_tpose_tpose(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_pose_tpose(const Pose *pose, const Temporal *temp); +extern int ever_ne_tpose_pose(const Temporal *temp, const Pose *pose); +extern int ever_ne_tpose_tpose(const Temporal *temp1, const Temporal *temp2); + +/*****************************************************************************/ + +extern Temporal *teq_pose_tpose(const Pose *pose, const Temporal *temp); +extern Temporal *teq_tpose_pose(const Temporal *temp, const Pose *pose); +extern Temporal *tne_pose_tpose(const Pose *pose, const Temporal *temp); +extern Temporal *tne_tpose_pose(const Temporal *temp, const Pose *pose); + +/*****************************************************************************/ + +/* Ever and always spatial relationship functions */ + + +/*****************************************************************************/ + +/* Spatiotemporal relationship functions */ + + +/*****************************************************************************/ + +#endif /* __MEOS_POSE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_rgeo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_rgeo.h new file mode 100644 index 0000000..6307540 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_rgeo.h @@ -0,0 +1,204 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURRGEO. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief External API of the Mobility Engine Open Source (MEOS) library + */ + +#ifndef __MEOS_RGEO_H__ +#define __MEOS_RGEO_H__ + +/* C */ +#include +/* MEOS */ +#include +#include +#include + +/***************************************************************************** + * Validity macros + *****************************************************************************/ + +/** + * @brief Macro for ensuring that the temporal value passed as argument is a + * temporal rigid geometry + * @note The macro works for the Temporal type and its subtypes TInstant, + * TSequence, and TSequenceSet + */ +#if MEOS + #define VALIDATE_TRGEOMETRY(temp, ret) \ + do { \ + if (! ensure_not_null((void *) (temp)) || \ + ! ensure_temporal_isof_type((Temporal *) (temp), T_TRGEOMETRY) ) \ + return (ret); \ + } while (0) +#else + #define VALIDATE_TRGEOMETRY(temp, ret) \ + do { \ + assert(temp); \ + assert(((Temporal *) (temp))->temptype == T_TRGEOMETRY); \ + } while (0) +#endif + +/*===========================================================================* + * Functions for temporal rigid geometries + *===========================================================================*/ + +/***************************************************************************** + * Input/output functions + *****************************************************************************/ + +extern char *trgeometry_out(const Temporal *temp); + +/***************************************************************************** + * Constructor functions + *****************************************************************************/ + +extern TInstant *trgeoinst_make(const GSERIALIZED *geom, const Pose *pose, TimestampTz t); +extern Temporal *geo_tpose_to_trgeometry(const GSERIALIZED *gs, const Temporal *temp); + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +extern Temporal *trgeometry_to_tpose(const Temporal *temp); +extern Temporal *trgeometry_to_tpoint(const Temporal *temp); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +extern TInstant *trgeometry_end_instant(const Temporal *temp); +extern TSequence *trgeometry_end_sequence(const Temporal *temp); +extern GSERIALIZED *trgeometry_end_value(const Temporal *temp); +extern GSERIALIZED *trgeometry_geom(const Temporal *temp); +extern TInstant *trgeometry_instant_n(const Temporal *temp, int n); +extern TInstant **trgeometry_instants(const Temporal *temp, int *count); +extern Set *trgeometry_points(const Temporal *temp); +extern Temporal *trgeometry_rotation(const Temporal *temp); +extern TSequence **trgeometry_segments(const Temporal *temp, int *count); +extern TSequence *trgeometry_sequence_n(const Temporal *temp, int i); +extern TSequence **trgeometry_sequences(const Temporal *temp, int *count); +extern TInstant *trgeometry_start_instant(const Temporal *temp); +extern TSequence *trgeometry_start_sequence(const Temporal *temp); +extern GSERIALIZED *trgeometry_start_value(const Temporal *temp); +extern bool trgeometry_value_n(const Temporal *temp, int n, GSERIALIZED **result); +extern GSERIALIZED *trgeometry_traversed_area(const Temporal *temp, bool unary_union); + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +extern Temporal *trgeometry_append_tinstant(Temporal *temp, const TInstant *inst, interpType interp, double maxdist, const Interval *maxt, bool expand); +extern Temporal *trgeometry_append_tsequence(Temporal *temp, const TSequence *seq, bool expand); +extern Temporal *trgeometry_delete_timestamptz(const Temporal *temp, TimestampTz t, bool connect); +extern Temporal *trgeometry_delete_tstzset(const Temporal *temp, const Set *s, bool connect); +extern Temporal *trgeometry_delete_tstzspan(const Temporal *temp, const Span *s, bool connect); +extern Temporal *trgeometry_delete_tstzspanset(const Temporal *temp, const SpanSet *ss, bool connect); +extern Temporal *trgeometry_round(const Temporal *temp, int maxdd); +extern Temporal *trgeometry_set_interp(const Temporal *temp, interpType interp); +extern TInstant *trgeometry_to_tinstant(const Temporal *temp); + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +extern Temporal *trgeometry_after_timestamptz(const Temporal *temp, TimestampTz t, bool strict); +extern Temporal *trgeometry_before_timestamptz(const Temporal *temp, TimestampTz t, bool strict); + +extern Temporal *trgeometry_restrict_value(const Temporal *temp, Datum value, bool atfunc); +extern Temporal *trgeometry_restrict_values(const Temporal *temp, const Set *s, bool atfunc); + +extern Temporal *trgeometry_restrict_timestamptz(const Temporal *temp, TimestampTz t, bool atfunc); +extern Temporal *trgeometry_restrict_tstzset(const Temporal *temp, const Set *s, bool atfunc); +extern Temporal *trgeometry_restrict_tstzspan(const Temporal *temp, const Span *s, bool atfunc); +extern Temporal *trgeometry_restrict_tstzspanset(const Temporal *temp, const SpanSet *ss, bool atfunc); + +// extern Temporal *trgeometry_at_geom(const Temporal *temp, const GSERIALIZED *gs); +// extern Temporal *trgeometry_at_stbox(const Temporal *temp, const STBox *box, bool border_inc); +// extern Temporal *trgeometry_at_elevation(const Temporal *temp, const Span *s); +// extern Temporal *trgeometry_minus_geom(const Temporal *temp, const GSERIALIZED *gs); +// extern Temporal *trgeometry_minus_stbox(const Temporal *temp, const STBox *box, bool border_inc); +// extern Temporal *trgeometry_minus_elevation(const Temporal *temp, const Span *s); + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +extern Temporal *tdistance_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tdistance_trgeometry_tpoint(const Temporal *temp1, const Temporal *temp2); +extern Temporal *tdistance_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern double nad_stbox_trgeometry(const STBox *box, const Temporal *temp); +extern double nad_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern double nad_trgeometry_stbox(const Temporal *temp, const STBox *box); +extern double nad_trgeometry_tpoint(const Temporal *temp1, const Temporal *temp2); +extern double nad_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern TInstant *nai_trgeometry_tpoint(const Temporal *temp1, const Temporal *temp2); +extern TInstant *nai_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern GSERIALIZED *shortestline_trgeometry_tpoint(const Temporal *temp1, const Temporal *temp2); +extern GSERIALIZED *shortestline_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); + +/***************************************************************************** + * Comparison functions + *****************************************************************************/ + +/* Ever/always and temporal comparison functions */ + +extern int always_eq_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern int always_eq_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int always_eq_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern int always_ne_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern int always_ne_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int always_ne_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern int ever_eq_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_eq_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_eq_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern int ever_ne_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern int ever_ne_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern int ever_ne_trgeometry_trgeometry(const Temporal *temp1, const Temporal *temp2); +extern Temporal *teq_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *teq_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); +extern Temporal *tne_geo_trgeometry(const GSERIALIZED *gs, const Temporal *temp); +extern Temporal *tne_trgeometry_geo(const Temporal *temp, const GSERIALIZED *gs); + +/*****************************************************************************/ + +/* Ever and always spatial relationship functions */ + + +/*****************************************************************************/ + +/* Spatiotemporal relationship functions */ + + +/*****************************************************************************/ + +#endif /* __MEOS_RGEO_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_tls.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_tls.h new file mode 100644 index 0000000..ded25d8 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/meos_tls.h @@ -0,0 +1,60 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2026, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2026, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Thread-local-storage qualifier macro used by MEOS to mark + * per-thread state. Kept in a stand-alone header so that vendored + * PostgreSQL headers (e.g. pgtime.h) can pick it up without pulling in + * the full meos.h. + */ + +#ifndef __MEOS_TLS_H__ +#define __MEOS_TLS_H__ + +/* + * Thread-local storage qualifier. C11 _Thread_local is supported by GCC, + * Clang, and MSVC 2019 16.10+; older compilers fall back to vendor + * extensions. If none of these is available the macro expands to + * nothing and MEOS state remains process-global (legacy behaviour). + */ +#if defined(__cplusplus) && __cplusplus >= 201103L +#define MEOS_TLS thread_local +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && \ + !defined(__STDC_NO_THREADS__) +#define MEOS_TLS _Thread_local +#elif defined(_MSC_VER) +#define MEOS_TLS __declspec(thread) +#elif defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) +#define MEOS_TLS __thread +#else +#define MEOS_TLS /* not supported; falls back to non-thread-safe globals */ +#endif + +#endif /* __MEOS_TLS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_internal_npoint.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_internal_npoint.h new file mode 100644 index 0000000..4c0b46b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_internal_npoint.h @@ -0,0 +1,116 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_internal_npoint_base Functions for static network points + * @ingroup meos_internal_npoint + * @brief Functions for static network points + * + * @defgroup meos_internal_npoint_set Functions for network point sets + * @ingroup meos_internal_npoint + * @brief Functions for network point sets + * + * @defgroup meos_internal_npoint_inout Input and output functions + * @ingroup meos_internal_npoint + * @brief Input and output functions for temporal network points + * + * @defgroup meos_internal_npoint_conversion Conversion functions + * @ingroup meos_internal_npoint + * @brief Conversion functions for temporal network points + * + * @defgroup meos_internal_npoint_accessor Accessor functions + * @ingroup meos_internal_npoint + * @brief Accessor functions for temporal network points + * + * @defgroup meos_internal_npoint_restrict Restriction functions + * @ingroup meos_internal_npoint + * @brief Restriction functions for temporal network points + * + * @defgroup meos_internal_npoint_dist Distance functions + * @ingroup meos_internal_npoint + * @brief Distance functions for temporal network points + * + * @defgroup meos_internal_npoint_agg Aggregate functions + * @ingroup meos_internal_npoint + * @brief Aggregate functions for temporal network points + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_npoint_base_inout Input and output functions + * @ingroup meos_internal_npoint_base + * @brief Input and output functions for static network points + * + * @defgroup meos_internal_npoint_base_constructor Constructor functions + * @ingroup meos_internal_npoint_base + * @brief Constructor functions for static network points + * + * @defgroup meos_internal_npoint_base_conversion Conversion functions + * @ingroup meos_internal_npoint_base + * @brief Conversion functions for static network points + * + * @defgroup meos_internal_npoint_base_accessor Accessor functions + * @ingroup meos_internal_npoint_base + * @brief Accessor functions for static network points + * + * @defgroup meos_internal_npoint_base_transf Transformation functions + * @ingroup meos_internal_npoint_base + * @brief Transformation functions for static network points + * + * @defgroup meos_internal_npoint_base_comp Comparison functions + * @ingroup meos_internal_npoint_base + * @brief Comparison functions for static network points + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_npoint_set_inout Input and output functions + * @ingroup meos_internal_npoint_set + * @brief Input and output functions for network point sets + * + * @defgroup meos_internal_npoint_set_constructor Constructor functions + * @ingroup meos_internal_npoint_set + * @brief Constructor functions for network point sets + * + * @defgroup meos_internal_npoint_set_conversion Conversion functions + * @ingroup meos_internal_npoint_set + * @brief Conversion functions for network point sets + * + * @defgroup meos_internal_npoint_set_accessor Accessor functions + * @ingroup meos_internal_npoint_set + * @brief Accessor functions for network point sets + * + * @defgroup meos_internal_npoint_set_setops Set operations + * @ingroup meos_internal_npoint_set + * @brief Set operations for network point sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_npoint.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_npoint.h new file mode 100644 index 0000000..e7c1c10 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/doxygen_meos_npoint.h @@ -0,0 +1,136 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_npoint_base Functions for static network points + * @ingroup meos_npoint + * @brief Functions for static network points + * + * @defgroup meos_npoint_set Functions for network point sets + * @ingroup meos_npoint + * @brief Functions for network point sets + * + * @defgroup meos_npoint_inout Input and output functions + * @ingroup meos_npoint + * @brief Input and output functions for temporal network points + * + * @defgroup meos_npoint_conversion Conversion functions + * @ingroup meos_npoint + * @brief Conversion functions for temporal network points + * + * @defgroup meos_npoint_accessor Accessor functions + * @ingroup meos_npoint + * @brief Accessor functions for temporal network points + * + * @defgroup meos_npoint_restrict Restriction functions + * @ingroup meos_npoint + * @brief Restriction functions for temporal network points + * + * @defgroup meos_npoint_dist Distance functions + * @ingroup meos_npoint + * @brief Distance functions for temporal network points + * + * @defgroup meos_npoint_agg Aggregate functions + * @ingroup meos_npoint + * @brief Aggregate functions for temporal network points + * + * @defgroup meos_npoint_comp Comparison functions + * @ingroup meos_npoint + * @brief Comparison functions for temporal network points + * + * @defgroup meos_npoint_comp_ever Ever and always comparison functions + * @ingroup meos_npoint_comp + * @brief Ever and always comparison functions for temporal network points + * + * @defgroup meos_npoint_comp_temp Temporal comparison functions + * @ingroup meos_npoint_comp + * @brief Temporal comparison functions for temporal network points + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_npoint_base_inout Input and output functions + * @ingroup meos_npoint_base + * @brief Input and output functions for static network points + * + * @defgroup meos_npoint_base_constructor Constructor functions + * @ingroup meos_npoint_base + * @brief Constructor functions for static network points + * + * @defgroup meos_npoint_base_conversion Conversion functions + * @ingroup meos_npoint_base + * @brief Conversion functions for static network points + * + * @defgroup meos_npoint_base_accessor Accessor functions + * @ingroup meos_npoint_base + * @brief Accessor functions for static network points + * + * @defgroup meos_npoint_base_route Route functions + * @ingroup meos_npoint_base + * @brief Route functions for static network points + * + * @defgroup meos_npoint_base_transf Transformation functions + * @ingroup meos_npoint_base + * @brief Transformation functions for static network points + * + * @defgroup meos_npoint_base_srid Spatial reference system functions + * @ingroup meos_npoint_base + * @brief Spatial reference system functions for static network points + * + * @defgroup meos_npoint_base_comp Comparison functions + * @ingroup meos_npoint_base + * @brief Comparison functions for static network points + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_npoint_set_inout Input and output functions + * @ingroup meos_npoint_set + * @brief Input and output functions for network point sets + * + * @defgroup meos_npoint_set_constructor Constructor functions + * @ingroup meos_npoint_set + * @brief Constructor functions for network point sets + * + * @defgroup meos_npoint_set_conversion Conversion functions + * @ingroup meos_npoint_set + * @brief Conversion functions for network point sets + * + * @defgroup meos_npoint_set_accessor Accessor functions + * @ingroup meos_npoint_set + * @brief Accessor functions for network point sets + * + * @defgroup meos_npoint_set_setops Set operations + * @ingroup meos_npoint_set + * @brief Set operations for network point sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint.h new file mode 100644 index 0000000..47768dd --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint.h @@ -0,0 +1,153 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for temporal network points. + */ + +#ifndef __TNPOINT_H__ +#define __TNPOINT_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/***************************************************************************** + * fmgr macros + *****************************************************************************/ + +/* Npoint */ +#define DatumGetNpointP(X) ((Npoint *) DatumGetPointer(X)) +#define NpointPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_NPOINT_P(X) DatumGetNpointP(PG_GETARG_DATUM(X)) +#define PG_RETURN_NPOINT_P(X) PG_RETURN_POINTER(X) + +/* Nsegment */ +#define DatumGetNsegmentP(X) ((Nsegment *) DatumGetPointer(X)) +#define NsegmentPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_NSEGMENT_P(X) DatumGetNsegmentP(PG_GETARG_DATUM(X)) +#define PG_RETURN_NSEGMENT_P(X) PG_RETURN_POINTER(X) + +/***************************************************************************** + * Npoint functions + *****************************************************************************/ + +/* Validity functions */ + +extern bool ensure_valid_tnpoint_npoint(const Temporal *temp, + const Npoint *np); +extern bool ensure_valid_tnpoint_npointset(const Temporal *temp, const Set *s); +extern bool ensure_valid_tnpoint_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_valid_tnpoint_stbox(const Temporal *temp, const STBox *box); +extern bool ensure_valid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); + +extern int tnpointsegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); + +extern bool common_rid_tnpoint_npoint(const Temporal *temp, const Npoint *np); +extern bool common_rid_tnpoint_npointset(const Temporal *temp, const Set *s); +extern bool common_rid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); + +/* Collinear functions */ + +extern bool npoint_collinear(const Npoint *np1, const Npoint *np2, + const Npoint *np3, double ratio); + +/* Interpolation functions */ + +extern Npoint *npointsegm_interpolate(const Npoint *start, const Npoint *end, + long double ratio); +extern long double npointsegm_locate(const Npoint *start, const Npoint *end, + const Npoint *value); + +/* General functions */ + +extern GSERIALIZED *npointarr_geom(Npoint **points, int count); +extern GSERIALIZED *nsegmentarr_geom(Nsegment **segments, int count); +extern Nsegment **nsegmentarr_normalize(Nsegment **segments, int *count); + +/* Input/output functions */ + +extern char *npoint_wkt_out(Datum value, int maxdd); + +/* Constructor functions */ + +extern void npoint_set(int64 rid, double pos, Npoint *np); +extern void nsegment_set(int64 rid, double pos1, double pos2, Nsegment *ns); + +/* Transformation functions */ + +extern Datum datum_npoint_round(Datum npoint, Datum size); + +/***************************************************************************** + * Temporal network point functions + *****************************************************************************/ + +/* Input/output functions */ + +/* Conversion functions */ + +extern TInstant *tnpointinst_tgeompointinst(const TInstant *inst); +extern TSequence *tnpointseq_tgeompointseq_disc(const TSequence *is); +extern TSequence *tnpointseq_tgeompointseq_cont(const TSequence *seq); +extern TSequenceSet *tnpointseqset_tgeompointseqset(const TSequenceSet *ss); + +extern TInstant *tgeompointinst_tnpointinst(const TInstant *inst); +extern TSequence *tgeompointseq_tnpointseq(const TSequence *seq); +extern TSequenceSet *tgeompointseqset_tnpointseqset(const TSequenceSet *ss); + +/* Accessor functions */ + +extern Nsegment **tnpointinst_positions(const TInstant *inst); +extern Nsegment **tnpointseq_positions(const TSequence *seq, int *count); +extern Nsegment **tnpointseqset_positions(const TSequenceSet *ss, int *count); +extern int64 tnpointinst_route(const TInstant *inst); +extern Set *tnpointinst_routes(const TInstant *inst); +extern Set *tnpointseq_disc_routes(const TSequence *is); +extern Set *tnpointseq_cont_routes(const TSequence *seq); +extern Set *tnpointseqset_routes(const TSequenceSet *ss); + +extern Nsegment *tnpointseq_linear_positions(const TSequence *seq); + +extern Temporal *tnpoint_restrict_stbox(const Temporal *temp, const STBox *box, + bool border_inc, bool atfunc); +extern Temporal *tnpoint_restrict_npoint(const Temporal *temp, const Npoint + *np, bool atfunc); +extern Temporal *tnpoint_restrict_npointset(const Temporal *temp, const Set *s, + bool atfunc); + +/*****************************************************************************/ + +#endif /* __TNPOINT_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_boxops.h new file mode 100644 index 0000000..18370fa --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_boxops.h @@ -0,0 +1,60 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Bounding box operators for temporal network points. + */ + +#ifndef __TNPOINT_BOXOPS_H__ +#define __TNPOINT_BOXOPS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "npoint/tnpoint.h" + +/*****************************************************************************/ + +extern bool npoint_set_stbox(const Npoint *np, STBox *box); +extern void npointarr_set_stbox(const Datum *values, int count, STBox *box); +extern bool nsegment_set_stbox(const Nsegment *ns, STBox *box); +extern bool npoint_timestamptz_set_stbox(const Npoint *np, TimestampTz t, + STBox *box); +extern bool npoint_tstzspan_set_stbox(const Npoint *np, const Span *s, + STBox *box); + +extern void tnpointinst_set_stbox(const TInstant *inst, STBox *box); +extern void tnpointinstarr_set_stbox(TInstant **inst, int count, + interpType interp, STBox *box); +extern void tnpointseq_expand_stbox(const TSequence *seq, const TInstant *inst); + +/*****************************************************************************/ + +#endif /* __TNPOINT_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_distance.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_distance.h new file mode 100644 index 0000000..1a7ece4 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_distance.h @@ -0,0 +1,48 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal distance for temporal circular buffers. + */ + +#ifndef __TNPOINT_DISTANCE_H__ +#define __TNPOINT_DISTANCE_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern Datum datum_npoint_distance(Datum np1, Datum np2); + +/*****************************************************************************/ + +#endif /* __TNPOINT_DISTANCE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_parser.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_parser.h new file mode 100644 index 0000000..0564100 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_parser.h @@ -0,0 +1,47 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for parsing static and temporal network points. + */ + +#ifndef __TNPOINT_PARSER_H__ +#define __TNPOINT_PARSER_H__ + +/* MEOS */ +#include "npoint/tnpoint.h" + +/*****************************************************************************/ + +extern Npoint *npoint_parse(const char **str, bool end); +extern Nsegment *nsegment_parse(const char **str); + +/*****************************************************************************/ + +#endif /* __TNPOINT_PARSER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_routeops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_routeops.h new file mode 100644 index 0000000..d2c9245 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_routeops.h @@ -0,0 +1,79 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Route identifier operators for temporal network points. + */ + +#ifndef __TNPOINT_ROUTEOPS_H__ +#define __TNPOINT_ROUTEOPS_H__ + +/* PostgreSQL */ +#include +#if ! MEOS + #include +#endif /* ! MEOS */ +/* MEOS */ +#include "npoint/tnpoint.h" + +/*****************************************************************************/ + +extern bool contains_rid_tnpoint_bigint(const Temporal *temp, int64 rid, + bool invert UNUSED); +extern bool contained_rid_tnpoint_bigint(const Temporal *temp, int64 rid, + bool invert); +extern bool same_rid_tnpoint_bigint(const Temporal *temp, int64 rid, + bool invert UNUSED); +extern bool overlaps_rid_tnpoint_bigintset(const Temporal *temp, const Set *s, + bool invert UNUSED); +extern bool contains_rid_tnpoint_bigintset(const Temporal *temp, const Set *s, + bool invert); +extern bool contained_rid_tnpoint_bigintset(const Temporal *temp, const Set *s, + bool invert); +extern bool same_rid_tnpoint_bigintset(const Temporal *temp, const Set *s, + bool invert UNUSED); +extern bool contains_rid_tnpoint_npoint(const Temporal *temp, const Npoint *np, + bool invert UNUSED); +extern bool contained_rid_npoint_tnpoint(const Temporal *temp, const Npoint *np, + bool invert); +extern bool same_rid_tnpoint_npoint(const Temporal *temp, const Npoint *np, + bool invert UNUSED); +extern bool overlaps_rid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); +extern bool contains_rid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); +extern bool contained_rid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); +extern bool same_rid_tnpoint_tnpoint(const Temporal *temp1, + const Temporal *temp2); + +/*****************************************************************************/ + +#endif /* __TNPOINT_ROUTEOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_spatialfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_spatialfuncs.h new file mode 100644 index 0000000..f4cdcb0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/npoint/tnpoint_spatialfuncs.h @@ -0,0 +1,61 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Geospatial functions for temporal network points. + */ + +#ifndef __TNPOINT_SPATIALFUNCS_H__ +#define __TNPOINT_SPATIALFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +/* Parameter tests */ + +extern bool ensure_same_rid_tnpointinst(const TInstant *inst1, + const TInstant *inst2); + +/* Restriction functions */ + +extern Temporal *tnpoint_restrict_geom(const Temporal *temp, + const GSERIALIZED *gs, bool atfunc); +extern Temporal *tnpoint_restrict_stbox(const Temporal *temp, const STBox *box, + bool border_inc, bool atfunc); + + +/*****************************************************************************/ + +#endif /* __TNPOINT_SPATIALFUNCS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_internal_pose.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_internal_pose.h new file mode 100644 index 0000000..77c36ea --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_internal_pose.h @@ -0,0 +1,124 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_internal_pose_base Functions for static poses + * @ingroup meos_internal_pose + * @brief Functions for static poses + * + * @defgroup meos_internal_pose_set Functions for pose sets + * @ingroup meos_internal_pose + * @brief Functions for pose sets + * + * @defgroup meos_internal_pose_inout Input and output functions + * @ingroup meos_internal_pose + * @brief Input and output functions for temporal poses + * + * @defgroup meos_internal_pose_conversion Conversion functions + * @ingroup meos_internal_pose + * @brief Conversion functions for temporal poses + * + * @defgroup meos_internal_pose_accessor Accessor functions + * @ingroup meos_internal_pose + * @brief Accessor functions for temporal poses + * + * @defgroup meos_internal_pose_restrict Restriction functions + * @ingroup meos_internal_pose + * @brief Restriction functions for temporal poses + * + * @defgroup meos_internal_pose_comp Comparison functions + * @ingroup meos_internal_pose + * @brief Comparison functions for temporal poses + * + * @defgroup meos_internal_pose_comp_ever Ever and always comparison functions + * @ingroup meos_internal_pose_comp + * @brief Ever and always comparison functions for temporal poses + * + * @defgroup meos_internal_pose_comp_temp Temporal comparison functions + * @ingroup meos_internal_pose_comp + * @brief Temporal comparison functions for temporal poses + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_pose_base_inout Input and output functions + * @ingroup meos_internal_pose_base + * @brief Input and output functions for static poses + * + * @defgroup meos_internal_pose_base_constructor Constructor functions + * @ingroup meos_internal_pose_base + * @brief Constructor functions for static poses + * + * @defgroup meos_internal_pose_base_conversion Conversion functions + * @ingroup meos_internal_pose_base + * @brief Conversion functions for static poses + * + * @defgroup meos_internal_pose_base_accessor Accessor functions + * @ingroup meos_internal_pose_base + * @brief Accessor functions for static poses + * + * @defgroup meos_internal_pose_base_transf Transformation functions + * @ingroup meos_internal_pose_base + * @brief Transformation functions for static poses + * + * @defgroup meos_internal_pose_base_srid Spatial reference system functions + * @ingroup meos_internal_pose_base + * @brief Spatial reference system functions for static poses + * + * @defgroup meos_internal_pose_base_comp Comparison functions + * @ingroup meos_internal_pose_base + * @brief Comparison functions for static poses + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_pose_set_inout Input and output functions + * @ingroup meos_internal_pose_set + * @brief Input and output functions for pose sets + * + * @defgroup meos_internal_pose_set_constructor Constructor functions + * @ingroup meos_internal_pose_set + * @brief Constructor functions for pose sets + * + * @defgroup meos_internal_pose_set_conversion Conversion functions + * @ingroup meos_internal_pose_set + * @brief Conversion functions for pose sets + * + * @defgroup meos_internal_pose_set_accessor Accessor functions + * @ingroup meos_internal_pose_set + * @brief Accessor functions for pose sets + * + * @defgroup meos_internal_pose_set_setops Set operations + * @ingroup meos_internal_pose_set + * @brief Set operations for pose sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_pose.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_pose.h new file mode 100644 index 0000000..9fd5b02 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/doxygen_meos_pose.h @@ -0,0 +1,136 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_pose_base Functions for static poses + * @ingroup meos_pose + * @brief Functions for static poses + * + * @defgroup meos_pose_set Functions for pose sets + * @ingroup meos_pose + * @brief Functions for pose sets + * + * @defgroup meos_pose_inout Input and output functions + * @ingroup meos_pose + * @brief Input and output functions for temporal poses + * + * @defgroup meos_geo_constructor Constructor functions + * @ingroup meos_geo + * @brief Constructor functions for temporal geometries + * + * @defgroup meos_pose_conversion Conversion functions + * @ingroup meos_pose + * @brief Conversion functions for temporal poses + * + * @defgroup meos_pose_accessor Accessor functions + * @ingroup meos_pose + * @brief Accessor functions for temporal poses + * + * @defgroup meos_pose_restrict Restriction functions + * @ingroup meos_pose + * @brief Restriction functions for temporal poses + * + * @defgroup meos_pose_comp Comparison functions + * @ingroup meos_pose + * @brief Comparison functions for temporal poses + * + * @defgroup meos_pose_comp_ever Ever and always comparison functions + * @ingroup meos_pose_comp + * @brief Ever and always comparison functions for temporal poses + * + * @defgroup meos_pose_comp_temp Temporal comparison functions + * @ingroup meos_pose_comp + * @brief Temporal comparison functions for temporal poses + * + * @defgroup meos_pose_distance Distance functions + * @ingroup meos_pose + * @brief Distance functions for temporal poses + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_pose_base_inout Input and output functions + * @ingroup meos_pose_base + * @brief Input and output functions for static poses + * + * @defgroup meos_pose_base_constructor Constructor functions + * @ingroup meos_pose_base + * @brief Constructor functions for static poses + * + * @defgroup meos_pose_base_conversion Conversion functions + * @ingroup meos_pose_base + * @brief Conversion functions for static poses + * + * @defgroup meos_pose_base_accessor Accessor functions + * @ingroup meos_pose_base + * @brief Accessor functions for static poses + * + * @defgroup meos_pose_base_transf Transformation functions + * @ingroup meos_pose_base + * @brief Transformation functions for static poses + * + * @defgroup meos_pose_base_srid Spatial reference system functions + * @ingroup meos_pose_base + * @brief Spatial reference system functions for static poses + * + * @defgroup meos_pose_base_bbox Bounding box functions + * @ingroup meos_pose_base + * @brief Bounding box functions for static poses + * + * @defgroup meos_pose_base_comp Comparison functions + * @ingroup meos_pose_base + * @brief Comparison functions for static poses + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_pose_set_inout Input and output functions + * @ingroup meos_pose_set + * @brief Input and output functions for pose sets + * + * @defgroup meos_pose_set_constructor Constructor functions + * @ingroup meos_pose_set + * @brief Constructor functions for pose sets + * + * @defgroup meos_pose_set_conversion Conversion functions + * @ingroup meos_pose_set + * @brief Conversion functions for pose sets + * + * @defgroup meos_pose_set_accessor Accessor functions + * @ingroup meos_pose_set + * @brief Accessor functions for pose sets + * + * @defgroup meos_pose_set_setops Set operations + * @ingroup meos_pose_set + * @brief Set operations for pose sets + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/pose.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/pose.h new file mode 100644 index 0000000..0c9d544 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/pose.h @@ -0,0 +1,118 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for static pose objects. + */ + +#ifndef __POSE_H__ +#define __POSE_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include + +/***************************************************************************** + * Struct definitions + *****************************************************************************/ + +/** + * @brief Structure to represent pose values + * @details + * flags (8 bits, x = unused): xxZXxxxx + * data: 2D: [x, y, theta] + * 3D: [x, y, z, W, X, Z, Y] + * + */ +struct Pose +{ + int32 vl_len_; /**< varlena header (do not touch directly!) */ + int8 flags; /**< flags */ + uint8_t srid[3]; /**< srid */ + double data[]; /**< position and orientation values */ +}; + +/***************************************************************************** + * fmgr macros + *****************************************************************************/ + +#define DatumGetPoseP(X) ((Pose *) DatumGetPointer(X)) +#define PosePGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_POSE_P(X) DatumGetPoseP(PG_GETARG_DATUM(X)) +#define PG_RETURN_POSE_P(X) PG_RETURN_POINTER(X) + +/*****************************************************************************/ + +/* Validity functions */ + +extern bool ensure_valid_pose_geo(const Pose *pose, const GSERIALIZED *gs); +extern bool ensure_valid_pose_stbox(const Pose *pose, const STBox *box); +extern bool ensure_valid_pose_pose(const Pose *pose1, const Pose *pose2); +extern bool ensure_valid_poseset_pose(const Set *s, const Pose *pose); + +/* Collinear and interpolation functions */ + +extern bool pose_collinear(const Pose *pose1, const Pose *pose2, + const Pose *pose3, double ratio); +extern Pose *posesegm_interpolate(const Pose *start, const Pose *end, + double ratio); +extern long double posesegm_locate(const Pose *start, const Pose *end, + const Pose *value); + +/* Input/output functions */ + +extern char *pose_wkt_out(const Pose *pose, bool extended, int maxdd); + +extern Pose *pose_parse(const char **str, bool end); + +extern Datum datum_pose_point(Datum pose); +extern Datum datum_pose_rotation(Datum pose); + +/* Transformation functions */ + +extern Datum datum_pose_round(Datum pose, Datum size); + +/* Distance */ + +extern Datum pose_distance(Datum pose1, Datum pose2); + +/* Box functions */ + +extern bool pose_set_stbox(const Pose *pose, STBox *box); +extern void posearr_set_stbox(const Datum *values, int count, STBox *box); +extern bool pose_timestamptz_set_stbox(const Pose *pose, TimestampTz t, + STBox *box); +extern bool pose_tstzspan_set_stbox(const Pose *pose, const Span *p, + STBox *box); + +/*****************************************************************************/ + +#endif /* __POSE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose.h new file mode 100644 index 0000000..3bf57ff --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose.h @@ -0,0 +1,61 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief General functions for temporal pose objects. + */ + +#ifndef __TPOSE_H__ +#define __TPOSE_H__ + +#include "temporal/temporal.h" +#include "pose/pose.h" + +/*****************************************************************************/ + +/* Validity functions */ + +extern bool ensure_valid_tpose_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_valid_tpose_pose(const Temporal *temp, const Pose *pose); +extern bool ensure_valid_tpose_stbox(const Temporal *temp, const STBox *box); +extern bool ensure_valid_tpose_tpose(const Temporal *temp1, + const Temporal *temp2); + +/* Interpolation functions */ + +extern int tposesegm_intersection_value(Datum start, Datum end, Datum value, + TimestampTz lower, TimestampTz upper, TimestampTz *t1, TimestampTz *t2); +extern int tposesegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); + +/*****************************************************************************/ + +#endif /* __TPOSE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_boxops.h new file mode 100644 index 0000000..a2629c9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_boxops.h @@ -0,0 +1,54 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Bounding box operators for temporal pose objects. + */ + +#ifndef __TPOSE_BOXOPS_H__ +#define __TPOSE_BOXOPS_H__ + +#include "temporal/temporal.h" +#include + +/*****************************************************************************/ + +/* Functions computing the bounding box at the creation of a temporal pose */ + +extern bool pose_set_stbox(const Pose *pose, STBox *box); +extern void posearr_set_stbox(const Datum *values, int count, STBox *box); + +extern void tposeinst_set_stbox(const TInstant *inst, STBox *box); +extern void tposeinstarr_set_stbox(TInstant **instants, int count, + STBox *box); +extern void tposeseq_expand_stbox(TSequence *seq, const TInstant *inst); + +/*****************************************************************************/ + +#endif /* __TPOSE_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_spatialfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_spatialfuncs.h new file mode 100644 index 0000000..6076e95 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/pose/tpose_spatialfuncs.h @@ -0,0 +1,57 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Spatial functions for temporal pose objects. + */ + +#ifndef __TPOSE_SPATIALFUNCS_H__ +#define __TPOSE_SPATIALFUNCS_H__ + +#include "temporal/temporal.h" +#include "pose/pose.h" + +/*****************************************************************************/ + +/* Trajectory function */ + +extern GSERIALIZED *tpose_trajectory(const Temporal *temp); + +/* Restriction functions */ + +extern Temporal *tpose_restrict_geom(const Temporal *temp, + const GSERIALIZED *gs, bool atfunc); +extern Temporal *tpose_restrict_stbox(const Temporal *temp, const STBox *box, + bool border_inc, bool atfunc); +extern Temporal *tpose_restrict_elevation(const Temporal *temp, const Span *s, + bool atfunc); + +/*****************************************************************************/ + +#endif /* __TPOSE_SPATIALFUNCS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/postgis_ext_defs.in.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/postgis_ext_defs.in.h new file mode 100644 index 0000000..243d0fb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/postgis_ext_defs.in.h @@ -0,0 +1,420 @@ +#ifndef _LIBLWGEOM_H +#define _LIBLWGEOM_H + +/******************************************************************/ + +/** +* Macros for manipulating the 'flags' byte. A uint8_t used as follows: +* VVSRGBMZ +* Version bit, followed by +* Validty, Solid, ReadOnly, Geodetic, HasBBox, HasM and HasZ flags. +*/ +#define LWFLAG_Z 0x01 +#define LWFLAG_M 0x02 +#define LWFLAG_BBOX 0x04 +#define LWFLAG_GEODETIC 0x08 +#define LWFLAG_READONLY 0x10 +#define LWFLAG_SOLID 0x20 + +#define FLAGS_GET_Z(flags) ((flags) & LWFLAG_Z) +#define FLAGS_GET_M(flags) (((flags) & LWFLAG_M)>>1) +#define FLAGS_GET_BBOX(flags) (((flags) & LWFLAG_BBOX)>>2) +#define FLAGS_GET_GEODETIC(flags) (((flags) & LWFLAG_GEODETIC)>>3) +#define FLAGS_GET_READONLY(flags) (((flags) & LWFLAG_READONLY)>>4) +#define FLAGS_GET_SOLID(flags) (((flags) & LWFLAG_SOLID)>>5) + +#define FLAGS_SET_Z(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_Z) : ((flags) & ~LWFLAG_Z)) +#define FLAGS_SET_M(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_M) : ((flags) & ~LWFLAG_M)) +#define FLAGS_SET_BBOX(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_BBOX) : ((flags) & ~LWFLAG_BBOX)) +#define FLAGS_SET_GEODETIC(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_GEODETIC) : ((flags) & ~LWFLAG_GEODETIC)) +#define FLAGS_SET_READONLY(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_READONLY) : ((flags) & ~LWFLAG_READONLY)) +#define FLAGS_SET_SOLID(flags, value) ((flags) = (value) ? ((flags) | LWFLAG_SOLID) : ((flags) & ~LWFLAG_SOLID)) + +#define FLAGS_NDIMS(flags) (2 + FLAGS_GET_Z(flags) + FLAGS_GET_M(flags)) +#define FLAGS_GET_ZM(flags) (FLAGS_GET_M(flags) + FLAGS_GET_Z(flags) * 2) +#define FLAGS_NDIMS_BOX(flags) (FLAGS_GET_GEODETIC(flags) ? 3 : FLAGS_NDIMS(flags)) + +/* +** Variants available for WKB and WKT output types +*/ + +#define WKB_ISO 0x01 +#define WKB_SFSQL 0x02 +#define WKB_EXTENDED 0x04 +#define WKB_NDR 0x08 +#define WKB_XDR 0x10 +#define WKB_HEX 0x20 +#define WKB_NO_NPOINTS 0x40 /* Internal use only */ +#define WKB_NO_SRID 0x80 /* Internal use only */ + +#define WKT_ISO 0x01 +#define WKT_SFSQL 0x02 +#define WKT_EXTENDED 0x04 + +typedef uint16_t lwflags_t; + +/******************************************************************/ + +typedef struct { + double afac, bfac, cfac, dfac, efac, ffac, gfac, hfac, ifac, xoff, yoff, zoff; +} AFFINE; + +/******************************************************************/ + +typedef struct +{ + double xmin, ymin, zmin; + double xmax, ymax, zmax; + int32_t srid; +} +BOX3D; + +/****************************************************************** +* GBOX structure. +* We include the flags (information about dimensionality), +* so we don't have to constantly pass them +* into functions that use the GBOX. +*/ +typedef struct +{ + lwflags_t flags; + double xmin; + double xmax; + double ymin; + double ymax; + double zmin; + double zmax; + double mmin; + double mmax; +} GBOX; + + +/****************************************************************** +* SPHEROID +* +* Standard definition of an ellipsoid (what wkt calls a spheroid) +* f = (a-b)/a +* e_sq = (a*a - b*b)/(a*a) +* b = a - fa +*/ +typedef struct +{ + double a; /* semimajor axis */ + double b; /* semiminor axis b = (a - fa) */ + double f; /* flattening f = (a-b)/a */ + double e; /* eccentricity (first) */ + double e_sq; /* eccentricity squared (first) e_sq = (a*a-b*b)/(a*a) */ + double radius; /* spherical average radius = (2*a+b)/3 */ + char name[20]; /* name of ellipse */ +} +SPHEROID; + +/****************************************************************** +* POINT2D, POINT3D, POINT3DM, POINT4D +*/ +typedef struct +{ + double x, y; +} +POINT2D; + +typedef struct +{ + double x, y, z; +} +POINT3DZ; + +typedef struct +{ + double x, y, z; +} +POINT3D; + +typedef struct +{ + double x, y, m; +} +POINT3DM; + +typedef struct +{ + double x, y, z, m; +} +POINT4D; + +/****************************************************************** +* POINTARRAY +* Point array abstracts a lot of the complexity of points and point lists. +* It handles 2d/3d translation +* (2d points converted to 3d will have z=0 or NaN) +* DO NOT MIX 2D and 3D POINTS! EVERYTHING* is either one or the other +*/ +typedef struct +{ + uint32_t npoints; /* how many points we are currently storing */ + uint32_t maxpoints; /* how many points we have space for in serialized_pointlist */ + + /* Use FLAGS_* macros to handle */ + lwflags_t flags; + + /* Array of POINT 2D, 3D or 4D, possibly misaligned. */ + uint8_t *serialized_pointlist; +} +POINTARRAY; + +/****************************************************************** +* GSERIALIZED +*/ + +typedef struct +{ + uint32_t size; /* For PgSQL use only, use VAR* macros to manipulate. */ + uint8_t srid[3]; /* 24 bits of SRID */ + uint8_t gflags; /* HasZ, HasM, HasBBox, IsGeodetic */ + uint8_t data[1]; /* See gserialized.txt */ +} GSERIALIZED; + +/****************************************************************** +* LWGEOM (any geometry type) +* +* Abstract type, note that 'type', 'bbox' and 'srid' are available in +* all geometry variants. +*/ +typedef struct +{ + GBOX *bbox; + void *data; + int32_t srid; + lwflags_t flags; + uint8_t type; + char pad[1]; /* Padding to 24 bytes (unused) */ +} +LWGEOM; + +/* POINTYPE */ +typedef struct +{ + GBOX *bbox; + POINTARRAY *point; /* hide 2d/3d (this will be an array of 1 point) */ + int32_t srid; + lwflags_t flags; + uint8_t type; /* POINTTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ +} +LWPOINT; /* "light-weight point" */ + +/* LINETYPE */ +typedef struct +{ + GBOX *bbox; + POINTARRAY *points; /* array of POINT3D */ + int32_t srid; + lwflags_t flags; + uint8_t type; /* LINETYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ +} +LWLINE; /* "light-weight line" */ + +/* TRIANGLE */ +typedef struct +{ + GBOX *bbox; + POINTARRAY *points; + int32_t srid; + lwflags_t flags; + uint8_t type; + char pad[1]; /* Padding to 24 bytes (unused) */ +} +LWTRIANGLE; + +/* CIRCSTRINGTYPE */ +typedef struct +{ + GBOX *bbox; + POINTARRAY *points; /* array of POINT(3D/3DM) */ + int32_t srid; + lwflags_t flags; + uint8_t type; /* CIRCSTRINGTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ +} +LWCIRCSTRING; /* "light-weight circularstring" */ + +/* POLYGONTYPE */ +typedef struct +{ + GBOX *bbox; + POINTARRAY **rings; /* list of rings (list of points) */ + int32_t srid; + lwflags_t flags; + uint8_t type; /* POLYGONTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t nrings; /* how many rings we are currently storing */ + uint32_t maxrings; /* how many rings we have space for in **rings */ +} +LWPOLY; /* "light-weight polygon" */ + +/* MULTIPOINTTYPE */ +typedef struct +{ + GBOX *bbox; + LWPOINT **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* MULTYPOINTTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWMPOINT; + +/* MULTILINETYPE */ +typedef struct +{ + GBOX *bbox; + LWLINE **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* MULTILINETYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWMLINE; + +/* MULTIPOLYGONTYPE */ +typedef struct +{ + GBOX *bbox; + LWPOLY **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* MULTIPOLYGONTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWMPOLY; + +/* COLLECTIONTYPE */ +typedef struct +{ + GBOX *bbox; + LWGEOM **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* COLLECTIONTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWCOLLECTION; + +/* COMPOUNDTYPE */ +typedef struct +{ + GBOX *bbox; + LWGEOM **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* COLLECTIONTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWCOMPOUND; /* "light-weight compound line" */ + +/* CURVEPOLYTYPE */ +typedef struct +{ + GBOX *bbox; + LWGEOM **rings; + int32_t srid; + lwflags_t flags; + uint8_t type; /* CURVEPOLYTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t nrings; /* how many rings we are currently storing */ + uint32_t maxrings; /* how many rings we have space for in **rings */ +} +LWCURVEPOLY; /* "light-weight polygon" */ + +/* MULTICURVE */ +typedef struct +{ + GBOX *bbox; + LWGEOM **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* MULTICURVE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWMCURVE; + +/* MULTISURFACETYPE */ +typedef struct +{ + GBOX *bbox; + LWGEOM **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* MULTISURFACETYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWMSURFACE; + +/* POLYHEDRALSURFACETYPE */ +typedef struct +{ + GBOX *bbox; + LWPOLY **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* POLYHEDRALSURFACETYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWPSURFACE; + +/* TINTYPE */ +typedef struct +{ + GBOX *bbox; + LWTRIANGLE **geoms; + int32_t srid; + lwflags_t flags; + uint8_t type; /* TINTYPE */ + char pad[1]; /* Padding to 24 bytes (unused) */ + uint32_t ngeoms; /* how many geometries we are currently storing */ + uint32_t maxgeoms; /* how many geometries we have space for in **geoms */ +} +LWTIN; + +/* Functions */ + +extern int32 geo_get_srid(const GSERIALIZED *g); + +/* PROJ */ + +struct PJconsts; +typedef struct PJconsts PJ; + +typedef struct LWPROJ +{ + PJ* pj; + + /* for pipeline transforms, whether to do a forward or inverse */ + bool pipeline_is_forward; + + /* Source crs is geographic: Used in geography calls (source srid == dst srid) */ + uint8_t source_is_latlong; + /* Source ellipsoid parameters */ + double source_semi_major_metre; + double source_semi_minor_metre; +} LWPROJ; + + +#endif /* _LIBLWGEOM_H */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/postgres_int_defs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/postgres_int_defs.h new file mode 100644 index 0000000..4d9087a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/postgres_int_defs.h @@ -0,0 +1,3 @@ +#include "../postgres/postgres.h" +#include "../postgres/utils/timestamp_def.h" +#include "../postgres/utils/date.h" diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_internal_rgeo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_internal_rgeo.h new file mode 100644 index 0000000..d03950e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_internal_rgeo.h @@ -0,0 +1,60 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_internal_rgeo_inout Input and output functions + * @ingroup meos_internal_rgeo + * @brief Input and output functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_conversion Conversion functions + * @ingroup meos_internal_rgeo + * @brief Conversion functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_accessor Accessor functions + * @ingroup meos_internal_rgeo + * @brief Accessor functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_restrict Restriction functions + * @ingroup meos_internal_rgeo + * @brief Restriction functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_comp Comparison functions + * @ingroup meos_internal_rgeo + * @brief Comparison functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_comp_ever Ever and always comparison functions + * @ingroup meos_internal_rgeo_comp + * @brief Ever and always comparison functions for temporal rigid geometries + * + * @defgroup meos_internal_rgeo_comp_temp Temporal comparison functions + * @ingroup meos_internal_rgeo_comp + * @brief Temporal comparison functions for temporal rigid geometries + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_rgeo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_rgeo.h new file mode 100644 index 0000000..a5bbb63 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/doxygen_meos_rgeo.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @defgroup meos_rgeo_inout Input and output functions + * @ingroup meos_rgeo + * @brief Input and output functions for temporal rigid geometries + * + * @defgroup meos_rgeo_conversion Conversion functions + * @ingroup meos_rgeo + * @brief Conversion functions for temporal rigid geometries + * + * @defgroup meos_rgeo_accessor Accessor functions + * @ingroup meos_rgeo + * @brief Accessor functions for temporal rigid geometries + * + * @defgroup meos_rgeo_restrict Restriction functions + * @ingroup meos_rgeo + * @brief Restriction functions for temporal rigid geometries + * + * @defgroup meos_rgeo_dist Distance functions + * @ingroup meos_rgeo + * @brief Distance functions for temporal rigid geometries + * + * @defgroup meos_rgeo_comp Comparison functions + * @ingroup meos_rgeo + * @brief Comparison functions for temporal rigid geometries + * + * @defgroup meos_rgeo_comp_ever Ever and always comparison functions + * @ingroup meos_rgeo_comp + * @brief Ever and always comparison functions for temporal rigid geometries + * + * @defgroup meos_rgeo_comp_temp Temporal comparison functions + * @ingroup meos_rgeo_comp + * @brief Temporal comparison functions for temporal rigid geometries + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo.h new file mode 100644 index 0000000..55b0a59 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo.h @@ -0,0 +1,88 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief General functions for temporal rigid geometries + */ + +#ifndef __TRGEO_H__ +#define __TRGEO_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" + +/** Symbolic constants for the temporal instant geometry constuctor */ +#define WITH_GEOM true +#define NO_GEOM false + +/***************************************************************************** + * Miscellaneous functions defined in trgeo.c + *****************************************************************************/ + +extern bool ensure_has_geom(int16 flags); +extern bool ensure_valid_trgeo_geo(const Temporal *temp, + const GSERIALIZED *gs); +extern bool ensure_valid_trgeo_stbox(const Temporal *temp, + const STBox *box); +extern bool ensure_valid_trgeo_trgeo(const Temporal *temp1, + const Temporal *temp2); +extern bool ensure_valid_trgeo_tpoint(const Temporal *temp1, + const Temporal *temp2); +extern const GSERIALIZED *trgeo_geom_p(const Temporal *temp); + +/* Input/output functions */ + +extern char *trgeo_wkt_out(const Temporal *temp, int maxdd, bool extended); + +/* Constructor functions */ + +extern TInstant *geo_tposeinst_to_trgeo(const GSERIALIZED *gs, + const TInstant *inst); +extern TSequence *geo_tposeseq_to_trgeo(const GSERIALIZED *gs, + const TSequence *seq); +extern TSequenceSet *geo_tposeseqset_to_trgeo(const GSERIALIZED *gs, + const TSequenceSet *ss); + +/* Conversion functions */ + + +/* Accessor functions */ + +extern bool trgeo_value_at_timestamptz(const Temporal *temp, TimestampTz t, + bool strict, Datum *result); + +/* Transformation functions */ + + +/*****************************************************************************/ + +#endif /* __TRGEO_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_all.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_all.h new file mode 100644 index 0000000..4e3be67 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_all.h @@ -0,0 +1,46 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief General functions for temporal rigid geometries + */ + +#ifndef __TRGEO_ALL_H__ +#define __TRGEO_ALL_H__ + +/* MEOS */ +#include "rgeo/trgeo.h" +#include "rgeo/trgeo_inst.h" +#include "rgeo/trgeo_seq.h" +#include "rgeo/trgeo_seqset.h" + +/*****************************************************************************/ + +#endif /* __TRGEO_ALL_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_boxops.h new file mode 100644 index 0000000..b75e43d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_boxops.h @@ -0,0 +1,60 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal rigid geometries + */ + +#ifndef __TRGEO_BOXOPS_H__ +#define __TRGEO_BOXOPS_H__ + +/* Postgres */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "geo/stbox.h" + +/*****************************************************************************/ + +/* Functions computing the bounding box at the creation of the temporal rigid + * geometry */ + +extern void trgeoinst_set_stbox(const GSERIALIZED *geom, const TInstant *inst, + STBox *box); +extern void trgeoinstarr_static_stbox(const GSERIALIZED *geom, + TInstant **instants, int count, STBox *box); +extern void trgeoinstarr_rotating_stbox(const GSERIALIZED *geom, + TInstant **instants, int count, STBox *box); +extern void trgeoinstarr_compute_bbox(const GSERIALIZED *geom, + TInstant **instants, int count, interpType interp, void *box); + +/*****************************************************************************/ + +#endif /* __TRGEO_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_distance.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_distance.h new file mode 100644 index 0000000..db8439c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_distance.h @@ -0,0 +1,106 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal rigid geometries + */ + +#ifndef __TRGEO_DISTANCE_H__ +#define __TRGEO_DISTANCE_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "pose/pose.h" + +/***************************************************************************** + * Struct definitions + *****************************************************************************/ + +/** Symbolic constants for temporal distance */ +#define MEOS_ANY 0 +#define MEOS_RIGHT 1 +#define MEOS_LEFT 2 + +/** Symbolic constants for equation solving */ +#define MEOS_SOLVE_0 true +#define MEOS_SOLVE_1 false + +/** Symbolic constants for cfp_elem */ +#define MEOS_CFP_STORE true +#define MEOS_CFP_STORE_NO false + +#define MEOS_CFP_FREE true +#define MEOS_CFP_FREE_NO false + +/* Closest features pair */ + +typedef struct { + LWGEOM *geom_1; + LWGEOM *geom_2; + Pose *pose_1; + Pose *pose_2; + bool free_pose_1; + bool free_pose_2; + uint32_t cf_1; + uint32_t cf_2; + TimestampTz t; + bool store; +} cfp_elem; + +/* List of CFPs */ + +typedef struct { + size_t count; + size_t size; + cfp_elem *arr; +} cfp_array; + +/* Closest features pair */ + +typedef struct { + double dist;; + TimestampTz t; +} tdist_elem; + +/* List of CFPs */ + +typedef struct { + size_t count; + size_t size; + tdist_elem *arr; +} tdist_array; + +/*****************************************************************************/ + +#endif /* __TRGEO_DISTANCE_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_inst.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_inst.h new file mode 100644 index 0000000..e1f2527 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_inst.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @brief Functions for temporal rigid instant geometries. + */ + +#ifndef __TRGEO_INST_H__ +#define __TRGEO_INST_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "pose/pose.h" + +/***************************************************************************** + * General functions + *****************************************************************************/ + +extern const GSERIALIZED *trgeoinst_geom_p(const TInstant *inst); +extern size_t trgeoinst_pose_varsize(const TInstant *inst); +extern void trgeoinst_set_pose(TInstant *inst); +extern TInstant *trgeoinst_tposeinst(const TInstant *inst); + +/* Constructor functions */ + +extern TInstant *trgeoinst_make1(const GSERIALIZED *geom, const Pose *pose, + TimestampTz t); + +/* Transformation functions */ + +extern TInstant *trgeoseq_to_tinstant(const TSequence *seq); +extern TInstant *trgeoseqset_to_tinstant(const TSequenceSet *ts); + +/*****************************************************************************/ + +#endif /* __TRGEO_INST_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_parser.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_parser.h new file mode 100644 index 0000000..bf16981 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_parser.h @@ -0,0 +1,49 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for parsing temporal rigid geometries + */ + +#ifndef __TRGEO_PARSER_H__ +#define __TRGEO_PARSER_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern Temporal *trgeo_parse(const char **str, MeosType temptype); + +/*****************************************************************************/ + +#endif /* __TRGEO_PARSER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seq.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seq.h new file mode 100644 index 0000000..aa181ad --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seq.h @@ -0,0 +1,77 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for temporal rigid geometries with sequence subtype + */ + +#ifndef __TRGEO_SEQ_H__ +#define __TRGEO_SEQ_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" + +/***************************************************************************** + * General functions + *****************************************************************************/ + +extern const GSERIALIZED *trgeoseq_geom_p(const TSequence *seq); + +extern size_t trgeoseq_pose_varsize(const TSequence *seq); +extern void trgeoseq_set_pose(TSequence *seq); +extern TSequence *trgeoseq_tposeseq(const TSequence *seq); + +/* Constructor functions */ + +extern bool trgeoseq_make_valid(const GSERIALIZED *geom, TInstant **instants, + int count, bool lower_inc, bool upper_inc, bool linear); +extern TSequence *trgeoseq_make1_exp(const GSERIALIZED *geom, TInstant **instants, + int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *trgeoseq_make1(const GSERIALIZED *geom, TInstant **instants, + int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *trgeoseq_make_exp(const GSERIALIZED *geom, TInstant **instants, + int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *trgeoseq_make(const GSERIALIZED *geom, TInstant **instants, + int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *trgeoseq_make_free_exp(const GSERIALIZED *geom, TInstant **instants, + int count, int maxcount, bool lower_inc, bool upper_inc, interpType interp, bool normalize); +extern TSequence *trgeoseq_make_free(const GSERIALIZED *geom, TInstant **instants, + int count, bool lower_inc, bool upper_inc, interpType interp, bool normalize); + +/* Transformation functions */ + +extern TSequence *trgeoinst_to_tsequence(const TInstant *inst, interpType interp); +extern TInstant *trgeoseq_to_tinstant(const TSequence *seq); + +/*****************************************************************************/ + +#endif /* __TRGEO_SEQ_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seqset.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seqset.h new file mode 100644 index 0000000..6437b35 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_seqset.h @@ -0,0 +1,74 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for temporal rigid geometries with sequence set subtype + */ + +#ifndef __TRGEO_SEQSET_H__ +#define __TRGEO_SEQSET_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/temporal.h" + +/***************************************************************************** + * General functions + *****************************************************************************/ + +extern const GSERIALIZED *trgeoseqset_geom_p(const TSequenceSet *ts); +extern TSequenceSet *trgeoseqset_tposeseqset(const TSequenceSet *ss); + +/* Constructor functions */ + +extern TSequenceSet *trgeoseqset_make1_exp(const GSERIALIZED *geom, + TSequence **sequences, int count, int maxcount, bool normalize); +extern TSequenceSet *trgeoseqset_make_exp(const GSERIALIZED *geom, + TSequence **sequences, int count, int maxcount, bool normalize); +extern TSequenceSet *trgeoseqset_make(const GSERIALIZED *geom, + TSequence **sequences, int count, bool normalize); +extern TSequenceSet *trgeoseqset_make_free(const GSERIALIZED *geom, + TSequence **sequences, int count, bool normalize); +extern TSequenceSet *trgeoseqset_make_gaps(const GSERIALIZED *geom, + TInstant **instants, int count, interpType interp, Interval *maxt, + double maxdist); + +/* Transformation functions */ + +extern TSequence *trgeoseqset_to_tsequence(const TSequenceSet *ss); +extern TSequence *trgeo_to_tsequence(const Temporal *temp, + const char *interp_str); +extern TSequenceSet *trgeo_to_tsequenceset(const Temporal *temp, + const char *interp_str); + +/*****************************************************************************/ + +#endif /* __TRGEO_SEQSET_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_spatialrels.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_spatialrels.h new file mode 100644 index 0000000..51b71ea --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_spatialrels.h @@ -0,0 +1,59 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal rigid geometries + */ + +#ifndef __TRGEO_SPATIALRELS_H__ +#define __TRGEO_SPATIALRELS_H__ + +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "pose/pose.h" + +/*****************************************************************************/ + +extern int ea_contains_geo_trgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever); +extern int ea_covers_geo_trgeo(const GSERIALIZED *gs, const Temporal *temp, + bool ever) +extern int ea_covers_trgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever); +extern int ea_disjoint_trgeo_geo(const Temporal *temp, const GSERIALIZED *gs, + bool ever) + +/*****************************************************************************/ + +#endif /* __TRGEO_SPATIALRELS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_utils.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_utils.h new file mode 100644 index 0000000..63908f8 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_utils.h @@ -0,0 +1,52 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Utility functions for temporal rigid geometries + */ + +#ifndef __TRGEO_UTILS_H__ +#define __TRGEO_UTILS_H__ + +/* Postgres */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "pose/pose.h" + +/*****************************************************************************/ + +extern bool ensure_same_geom(const GSERIALIZED *gs1, const GSERIALIZED *gs2); +extern void lwgeom_apply_pose(const Pose *pose, LWGEOM *geom); +extern double geom_radius(const GSERIALIZED *gs); + +/*****************************************************************************/ + +#endif /* __TRGEO_UTILS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_vclip.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_vclip.h new file mode 100644 index 0000000..30a450a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/rgeo/trgeo_vclip.h @@ -0,0 +1,74 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal rigid geometries. + */ + +#ifndef __TRGEO_VCLIP_H__ +#define __TRGEO_VCLIP_H__ + +/* C */ +#include +/* PostgreSQL */ +#include +/* PostGIS */ +#include +/* MEOS */ +#include "temporal/temporal.h" +#include "pose/pose.h" + +/***************************************************************************** + * Struct definitions + *****************************************************************************/ + +/** Max iterations to avoid infinite loops */ +#define MEOS_MAX_ITERS 1000 + +/** Symbolic constants for v-clip */ +#define MEOS_CONTINUE 0 +#define MEOS_DISJOINT 1 +#define MEOS_INTERSECT -1 + +/*****************************************************************************/ + +/* V-clip functions */ + +extern int v_clip_tpoly_point(const LWPOLY *poly, const LWPOINT *point, + const Pose *pose, uint32_t *poly_feature, double *dist); +extern int v_clip_tpoly_tpoly(const LWPOLY *poly1, const LWPOLY *poly2, + const Pose *pose1, const Pose *pose2, uint32_t *poly1_feature, + uint32_t *poly2_feature, double *dist); + +extern void apply_pose_point4d(POINT4D *p, const Pose *pose); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doublen.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doublen.h new file mode 100644 index 0000000..0471bf3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doublen.h @@ -0,0 +1,109 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Internal types used in particular for computing the average and + * centroid temporal aggregates. + */ + +#ifndef __DOUBLEN_H__ +#define __DOUBLEN_H__ + +/* C */ +#include + +/*****************************************************************************/ + +/** + * Structure to represent values of the internal type for computing aggregates + * for temporal number types + */ +typedef struct +{ + double a; + double b; +} double2; + +/** + * Structure to represent values of the internal type for computing aggregates + * for 2D temporal points + */ +typedef struct +{ + double a; + double b; + double c; +} double3; + +/** + * Structure to represent values of the internal type for computing aggregates + * for 3D temporal points + */ +typedef struct +{ + double a; + double b; + double c; + double d; +} double4; + +/*****************************************************************************/ + +extern char *double2_out(const double2 *d, int maxdd); +extern void double2_set(double a, double b, double2 *result); +extern double2 *double2_add(const double2 *d1, const double2 *d2); +extern bool double2_eq(const double2 *d1, const double2 *d2); + +extern char *double3_out(const double3 *d, int maxdd); +extern void double3_set(double a, double b, double c, double3 *result); +extern double3 *double3_add(const double3 *d1, const double3 *d2); +extern bool double3_eq(const double3 *d1, const double3 *d2); + +extern char *double4_out(const double4 *d, int maxdd); +extern void double4_set(double a, double b, double c, double d, double4 *result); +extern double4 *double4_add(const double4 *d1, const double4 *d2); +extern bool double4_eq(const double4 *d1, const double4 *d2); + +extern bool double2_collinear(const double2 *x1, const double2 *x2, + const double2 *x3, double ratio); +extern bool double3_collinear(const double3 *x1, const double3 *x2, + const double3 *x3, double ratio); +extern bool double4_collinear(const double4 *x1, const double4 *x2, + const double4 *x3, double ratio); + +extern double2 *double2segm_interpolate(const double2 *start, + const double2 *end, long double ratio); +extern double3 *double3segm_interpolate(const double3 *start, + const double3 *end, long double ratio); +extern double4 *double4segm_interpolate(const double4 *start, + const double4 *end, long double ratio); + +/*****************************************************************************/ + +#endif /* __DOUBLEN_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos.h new file mode 100644 index 0000000..68a8856 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos.h @@ -0,0 +1,341 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @mainpage MEOS and MobilityDB Developer's Documentation + * + * \htmlonly + *
+ *
+ * MEOS logo + *
+ *
+ * MobilityDB logo + *
+ *
+ * \endhtmlonly + * + * @image latex meos-logo.png width=10% + * @image latex mobilitydb-logo.png width=10% + * + * This document defines the developer's documentation of both the MEOS library + * and MobilityDB. The documentation is divided into modules, where the + * top-level modules are as follows: + * + * - MEOS library + * - MEOS API + * - Internal functions + * - MobilityDB API + * + * \tableofcontents + * + * Please refer to the Modules tab for a detailed account of these modules. + */ + +/***************************************************************************** + * Sections of the external MEOS API + * These sections follow the ones of the MobilityDB documentation although + * some subsections are merged into a single one + *****************************************************************************/ + +/** + * @defgroup meos MEOS library + * @brief Mobility Engine Open Source (MEOS) library + * + * @defgroup meos_api External API + * @ingroup meos + * @brief External API of the Mobility Engine Open Source (MEOS) library + * + * @defgroup meos_internal Internal API + * @ingroup meos + * @brief Internal API of the Mobility Engine Open Source (MEOS) library + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_base_types Functions for base and time types + * @ingroup meos_api + * @brief Functions for base and time types + * + * @defgroup meos_setspan Functions for set and span types + * @ingroup meos_api + * @brief Functions for set and span types + * + * @defgroup meos_box Functions for temporal boxes + * @ingroup meos_api + * @brief Functions for temporal boxes + * + * @defgroup meos_temporal Functions for temporal types + * @ingroup meos_api + * @brief Functions for temporal types + * + * @defgroup meos_geo Functions for temporal geometries + * @ingroup meos_api + * @brief Functions for temporal geometries + * + * @defgroup meos_cbuffer Functions for temporal circular buffers + * @ingroup meos_api + * @brief Functions for temporal temporal circular buffers + * + * @defgroup meos_npoint Functions for temporal network points + * @ingroup meos_api + * @brief Functions for temporal network points + * + * @defgroup meos_pose Functions for temporal poses + * @ingroup meos_api + * @brief Functions for temporal poses + * + * @defgroup meos_rgeo Functions for temporal rigid geometries + * @ingroup meos_api + * @brief Functions for temporal rigid geometries + * + * @defgroup meos_misc Miscellaneous functions + * @ingroup meos_api + * @brief Miscellaneous functions + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_setspan_inout Input and output functions + * @ingroup meos_setspan + * @brief Input and output functions for set and span types + * + * @defgroup meos_setspan_constructor Constructor functions + * @ingroup meos_setspan + * @brief Constructor functions for set and span types + * + * @defgroup meos_setspan_conversion Conversion functions + * @ingroup meos_setspan + * @brief Conversion functions for set and span types + * + * @defgroup meos_setspan_accessor Accessor functions + * @ingroup meos_setspan + * @brief Accessor functions for set and span types + * + * @defgroup meos_setspan_transf Transformation functions + * @ingroup meos_setspan + * @brief Transformation functions for set and span types + * + * @defgroup meos_setspan_srid Spatial reference system functions + * @ingroup meos_setspan + * @brief Spatial reference system functions for set and span types + * + * @defgroup meos_setspan_comp Comparison functions + * @ingroup meos_setspan + * @brief Comparison functions for set and span types + * + * @defgroup meos_setspan_bbox Bounding box functions + * @ingroup meos_setspan + * @brief Bounding box functions for set and span types + * + * @defgroup meos_setspan_bbox_split Split functions + * @ingroup meos_setspan_bbox + * @brief Split functions for set and span types + * + * @defgroup meos_setspan_topo Topological functions + * @ingroup meos_setspan_bbox + * @brief Topological functions for set and span types + * + * @defgroup meos_setspan_pos Position functions + * @ingroup meos_setspan_bbox + * @brief Position functions for set and span types + * + * @defgroup meos_setspan_set Set functions + * @ingroup meos_setspan + * @brief Set functions for set and span types + * + * @defgroup meos_setspan_dist Distance functions + * @ingroup meos_setspan + * @brief Distance functions for set and span types + * + * @defgroup meos_setspan_agg Aggregate functions + * @ingroup meos_setspan + * @brief Aggregate functions for set and span types + * + * @defgroup meos_setspan_bin Bin functions + * @ingroup meos_setspan + * @brief Bin functions for set and span types + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_box_inout Input and output functions + * @ingroup meos_box + * @brief Input and output functions for temporal boxes + * + * @defgroup meos_box_constructor Constructor functions + * @ingroup meos_box + * @brief Constructor functions for temporal boxes + * + * @defgroup meos_box_conversion Conversion functions + * @ingroup meos_box + * @brief Conversion functions for temporal boxes + * + * @defgroup meos_box_accessor Accessor functions + * @ingroup meos_box + * @brief Accessor functions for temporal boxes + * + * @defgroup meos_box_transf Transformation functions + * @ingroup meos_box + * @brief Transformation functions for temporal boxes + * + * @defgroup meos_box_srid Spatial reference system functions + * @ingroup meos_box + * @brief Spatial reference system functions for temporal boxes + * + * @defgroup meos_box_set Set functions + * @ingroup meos_box + * @brief Set functions for temporal boxes + * + * @defgroup meos_box_bbox Bounding box functions + * @ingroup meos_box + * @brief Bounding box functions for temporal boxes + * + * @defgroup meos_box_bbox_topo Topological functions + * @ingroup meos_box_bbox + * @brief Topological functions for temporal boxes + * + * @defgroup meos_box_bbox_pos Position functions + * @ingroup meos_box_bbox + * @brief Position functions for temporal boxes + * + * @defgroup meos_box_comp Comparison functions + * @ingroup meos_box + * @brief Comparison functions for temporal boxes + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_temporal_inout Input and output functions + * @ingroup meos_temporal + * @brief Input and output functions for temporal types + * + * @defgroup meos_temporal_constructor Constructor functions + * @ingroup meos_temporal + * @brief Constructor functions for temporal types + * + * @defgroup meos_temporal_conversion Conversion functions + * @ingroup meos_temporal + * @brief Conversion functions for temporal types + * + * @defgroup meos_temporal_accessor Accessor functions + * @ingroup meos_temporal + * @brief Accessor functions for temporal types + * + * @defgroup meos_temporal_transf Transformation functions + * @ingroup meos_temporal + * @brief Transformation functions for temporal types + * + * @defgroup meos_temporal_modif Modification functions + * @ingroup meos_temporal + * @brief Modification functions for temporal types + * + * @defgroup meos_temporal_restrict Restriction functions + * @ingroup meos_temporal + * @brief Restriction functions for temporal types + * + * @defgroup meos_temporal_comp Comparison functions + * @ingroup meos_temporal + * @brief Comparison functions for temporal types + * + * @defgroup meos_temporal_comp_trad Traditional comparison functions + * @ingroup meos_temporal_comp + * @brief Traditional comparison functions for temporal types + * + * @defgroup meos_temporal_comp_ever Ever and always comparison functions + * @ingroup meos_temporal_comp + * @brief Ever and always comparison functions for temporal types + * + * @defgroup meos_temporal_comp_temp Temporal comparison functions + * @ingroup meos_temporal_comp + * @brief Temporal comparison functions for temporal types + * + * @defgroup meos_temporal_bbox Bounding box functions + * @ingroup meos_temporal + * @brief Bounding box functions for temporal types + * + * @defgroup meos_temporal_bbox_split Split functions + * @ingroup meos_temporal_bbox + * @brief Split functions for temporal types + * + * @defgroup meos_temporal_bbox_topo Topological functions + * @ingroup meos_temporal_bbox + * @brief Topological functions for temporal types + * + * @defgroup meos_temporal_bbox_pos Position functions + * @ingroup meos_temporal_bbox + * @brief Position functions for temporal types + * + * @defgroup meos_temporal_bool Boolean functions + * @ingroup meos_temporal + * @brief Boolean functions for temporal types + * + * @defgroup meos_temporal_math Mathematical functions + * @ingroup meos_temporal + * @brief Mathematical functions for temporal types + * + * @defgroup meos_temporal_text Text functions + * @ingroup meos_temporal + * @brief Text functions for temporal types + * + * @defgroup meos_temporal_dist Distance functions + * @ingroup meos_temporal + * @brief Distance functions for temporal types + * + * @defgroup meos_temporal_agg Aggregate functions + * @ingroup meos_temporal + * @brief Aggregate functions for temporal types + * + * @defgroup meos_temporal_analytics Analytics functions + * @ingroup meos_temporal + * @brief Analytics functions for temporal types + * + * @defgroup meos_temporal_analytics_simplify Simplification functions + * @ingroup meos_temporal_analytics + * @brief Simplification functions for temporal types + * + * @defgroup meos_temporal_analytics_reduction Reduction functions + * @ingroup meos_temporal_analytics + * @brief Reduction functions for temporal types + * + * @defgroup meos_temporal_analytics_similarity Similarity functions + * @ingroup meos_temporal_analytics + * @brief Similarity functions for temporal types + * + * @defgroup meos_temporal_analytics_tile Tile functions + * @ingroup meos_temporal_analytics + * @brief Tile functions for temporal types + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos_internal.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos_internal.h new file mode 100644 index 0000000..59966d5 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/doxygen_meos_internal.h @@ -0,0 +1,217 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief MEOS Developer's Documentation: Internal API + */ + +/***************************************************************************** + * Sections of the MEOS internal API + *****************************************************************************/ + +/** + * @defgroup meos_internal_setspan Functions for set and span types + * @ingroup meos_internal + * @brief Functions for set and span types + * + * @defgroup meos_internal_box Functions for temporal boxes + * @ingroup meos_internal + * @brief Functions for temporal boxes + * + * @defgroup meos_internal_temporal Functions for temporal types + * @ingroup meos_internal + * @brief Functions for temporal types + * + * @defgroup meos_internal_geo Functions for temporal geometries + * @ingroup meos_internal + * @brief Functions for temporal geometries + * + * @defgroup meos_internal_cbuffer Functions for temporal circular buffers + * @ingroup meos_internal + * @brief Functions for temporal circular buffers + * + * @defgroup meos_internal_npoint Functions for temporal network points + * @ingroup meos_internal + * @brief Functions for temporal network points + * + * @defgroup meos_internal_pose Functions for temporal poses + * @ingroup meos_internal + * @brief Functions for temporal poses + * + * @defgroup meos_internal_rgeo Functions for temporal rigid geometries + * @ingroup meos_internal + * @brief Functions for temporal rigid geometries + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_setspan_inout Input and output functions + * @ingroup meos_internal_setspan + * @brief Input and output functions for set and span types + * + * @defgroup meos_internal_setspan_constructor Constructor functions + * @ingroup meos_internal_setspan + * @brief Constructor functions for set and span types + * + * @defgroup meos_internal_setspan_conversion Conversion functions + * @ingroup meos_internal_setspan + * @brief Conversion functions for set and span types + * + * @defgroup meos_internal_setspan_accessor Accessor functions + * @ingroup meos_internal_setspan + * @brief Accessor functions for set and span types + * + * @defgroup meos_internal_setspan_transf Transformation functions + * @ingroup meos_internal_setspan + * @brief Transformation functions for set and span types + * + * @defgroup meos_internal_setspan_bbox Bounding box functions + * @ingroup meos_internal_setspan + * @brief Bounding box functions for set and span types + * + * @defgroup meos_internal_setspan_topo Topological functions + * @ingroup meos_internal_setspan_bbox + * @brief Topological functions for set and span types + * + * @defgroup meos_internal_setspan_pos Position functions + * @ingroup meos_internal_setspan_bbox + * @brief Position functions for set and span types + * + * @defgroup meos_internal_setspan_set Set functions + * @ingroup meos_internal_setspan + * @brief Set functions for set and span types + * + * @defgroup meos_internal_setspan_dist Distance functions + * @ingroup meos_internal_setspan + * @brief Distance functions for set and span types + * + * @defgroup meos_internal_setspan_agg Aggregate functions + * @ingroup meos_internal_setspan + * @brief Aggregate functions for set and span types + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_box_constructor Constructor functions + * @ingroup meos_internal_box + * @brief Constructor functions for box types + * + * @defgroup meos_internal_box_conversion Conversion functions + * @ingroup meos_internal_box + * @brief Conversion functions for box types + * + * @defgroup meos_internal_box_transf Transformation functions + * @ingroup meos_internal_box + * @brief Transformation functions for box types + * + * @defgroup meos_internal_box_set Set functions + * @ingroup meos_internal_box + * @brief Set functions for box types + */ + +/*****************************************************************************/ + +/** + * @defgroup meos_internal_temporal_inout Input and output functions + * @ingroup meos_internal_temporal + * @brief Input and output functions for temporal types + * + * @defgroup meos_internal_temporal_constructor Constructor functions + * @ingroup meos_internal_temporal + * @brief Constructor functions for temporal types + * + * @defgroup meos_internal_temporal_conversion Conversion functions + * @ingroup meos_internal_temporal + * @brief Conversion functions for temporal types + * + * @defgroup meos_internal_temporal_accessor Accessor functions + * @ingroup meos_internal_temporal + * @brief Accessor functions for temporal types + * + * @defgroup meos_internal_temporal_transf Transformation functions + * @ingroup meos_internal_temporal + * @brief Transformation functions for temporal types + * + * @defgroup meos_internal_temporal_modif Modification functions + * @ingroup meos_internal_temporal + * @brief Modification functions for temporal types + * + * @defgroup meos_internal_temporal_restrict Restriction functions + * @ingroup meos_internal_temporal + * @brief Restriction functions for temporal types + * + * @defgroup meos_internal_temporal_comp Comparison functions + * @ingroup meos_internal_temporal + * @brief Comparison functions for temporal types + * + * @defgroup meos_internal_temporal_bbox Bounding box functions + * @ingroup meos_internal_temporal + * @brief Bounding box functions for temporal types + * + * @defgroup meos_internal_temporal_math Mathematical functions + * @ingroup meos_internal_temporal + * @brief Mathematical functions for temporal types + * + * @defgroup meos_internal_temporal_dist Distance functions + * @ingroup meos_internal_temporal + * @brief Distance functions for temporal types + * + * @defgroup meos_internal_temporal_comp_trad Traditional comparison functions + * @ingroup meos_internal_temporal_comp + * @brief Tranditional comparison functions for temporal types + * + * @defgroup meos_internal_temporal_comp_ever Ever/always comparison functions + * @ingroup meos_internal_temporal_comp + * @brief Ever and always comparison functions for temporal types + * + * @defgroup meos_internal_temporal_comp_temp Temporal comparison functions + * @ingroup meos_internal_temporal_comp + * @brief Temporal comparison functions for temporal types + * + * @defgroup meos_internal_temporal_spatial Spatial functions + * @ingroup meos_internal_temporal + * @brief Spatial functions for temporal geos + * + * @defgroup meos_internal_temporal_spatial_accessor Spatial accessor functions + * @ingroup meos_internal_temporal_spatial + * @brief Spatial accessor functions for temporal geos + * + * @defgroup meos_internal_temporal_spatial_transf Spatial transformation functions + * @ingroup meos_internal_temporal_spatial + * @brief Spatial transformation functions for temporal geos + * + * @defgroup meos_internal_temporal_agg Aggregate functions + * @ingroup meos_internal_temporal + * @brief Aggregate functions for temporal types + */ + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/lifting.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/lifting.h new file mode 100644 index 0000000..0a93af8 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/lifting.h @@ -0,0 +1,112 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Generic functions for lifting functions and operators on temporal + * types. + */ + +#ifndef __LIFTING_H__ +#define __LIFTING_H__ + +/* MEOS */ +#include +#include "temporal/temporal.h" +#include "temporal/meos_catalog.h" + +/** + * Structure to represent the information about lifted functions + * + * The mandatory parameters are `func`, `numparam`, and `restype`. These + * parameters are used by function `tfunc_temporal`, which applies the lifted + * function to every instant of the temporal value. The remaining parameters + * are used by functions `tfunc_temporal_base` and `tfunc_temporal_temporal` + * that apply the lifted function to two base values. + */ + +#define MAX_PARAMS 1 +#define MAX_ARGS 2 + +typedef struct +{ + varfunc func; /**< Variadic function that is lifted */ + int numparam; /**< Number of parameters of the function */ + Datum param[MAX_PARAMS]; /**< Datum array for the parameters of the function */ + MeosType argtype[MAX_ARGS]; /**< Type of the arguments of the function */ + MeosType restype; /**< Type of the result of the function */ + bool reslinear; /**< True if the result has linear interpolation */ + bool invert; /**< True if the arguments of the function must be inverted */ + bool discont; /**< True if the function has instantaneous discontinuities */ + bool ever; /**< True/false when computing the ever/always semantics */ + tpfunc_unary tpfn_unary; /**< Turning point function for unary lifts */ + tpfunc_base tpfn_base; /**< Turning point function for temporal and base types*/ + tpfunc_temp tpfn_temp; /**< Turning point function for two temporal types */ +} LiftedFunctionInfo; + +/*****************************************************************************/ + +extern TInstant *tfunc_tinstant(const TInstant *inst, + LiftedFunctionInfo *lfinfo); +extern TSequence *tfunc_tsequence(const TSequence *seq, + LiftedFunctionInfo *lfinfo); +extern TSequenceSet *tfunc_tsequenceset(const TSequenceSet *ss, + LiftedFunctionInfo *lfinfo); +extern Temporal *tfunc_temporal(const Temporal *temp, + LiftedFunctionInfo *lfinfo); + +extern TInstant *tfunc_tinstant_base(const TInstant *inst, Datum value, + LiftedFunctionInfo *lfinfo); +extern TSequence *tfunc_tsequence_base(const TSequence *seq, Datum value, + LiftedFunctionInfo *lfinfo); +extern TSequenceSet *tfunc_tsequenceset_base(const TSequenceSet *ss, Datum value, + LiftedFunctionInfo *lfinfo); +extern Temporal *tfunc_temporal_base(const Temporal *temp, Datum value, + LiftedFunctionInfo *lfinfo); + +extern TInstant *tfunc_tinstant_tinstant(const TInstant *inst1, + const TInstant *inst2, LiftedFunctionInfo *lfinfo); +extern TSequence *tfunc_tdiscseq_tdiscseq(const TSequence *seq1, + const TSequence *seq2, LiftedFunctionInfo *lfinfo); +extern Temporal *tfunc_tcontseq_tcontseq(const TSequence *seq1, + const TSequence *seq2, LiftedFunctionInfo *lfinfo); +extern TSequenceSet *tfunc_tsequenceset_tsequenceset(const TSequenceSet *ss1, + const TSequenceSet *ss2, LiftedFunctionInfo *lfinfo); +extern Temporal *tfunc_temporal_temporal(const Temporal *temp1, + const Temporal *temp2, LiftedFunctionInfo *lfinfo); + +/*****************************************************************************/ + +extern int eafunc_temporal_base(const Temporal *temp, Datum value, + LiftedFunctionInfo *lfinfo); +extern int eafunc_temporal_temporal(const Temporal *temp1, + const Temporal *temp2, LiftedFunctionInfo *lfinfo); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/meos_catalog.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/meos_catalog.h new file mode 100644 index 0000000..ffdf54d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/meos_catalog.h @@ -0,0 +1,311 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for building a cache of temporal types and operators. + */ + +#ifndef __MEOS_CATALOG_H__ +#define __MEOS_CATALOG_H__ + +/* C */ +#include +/* PostgreSQL */ +#ifndef int16 +typedef signed short int16; +#endif +/* MEOS */ +#include + +/***************************************************************************** + * Data structures + *****************************************************************************/ + +/** + * @brief Enumeration that defines the built-in and temporal types used in + * MobilityDB. + */ +typedef enum +{ + T_UNKNOWN = 0, /**< unknown type */ + T_BOOL = 1, /**< boolean type */ + T_DATE = 2, /**< date type */ + T_DATEMULTIRANGE = 3, /**< PostgreSQL date multirange type */ + T_DATERANGE = 4, /**< PostgreSQL date range type */ + T_DATESET = 5, /**< date set type */ + T_DATESPAN = 6, /**< date span type */ + T_DATESPANSET = 7, /**< date span set type */ + T_DOUBLE2 = 8, /**< double2 type */ + T_DOUBLE3 = 9, /**< double3 type */ + T_DOUBLE4 = 10, /**< double4 type */ + T_FLOAT8 = 11, /**< float8 type */ + T_FLOATSET = 12, /**< float8 set type */ + T_FLOATSPAN = 13, /**< float8 span type */ + T_FLOATSPANSET = 14, /**< float8 span set type */ + T_INT4 = 15, /**< int4 type */ + T_INT4MULTIRANGE = 16, /**< PostgreSQL int4 multirange type */ + T_INT4RANGE = 17, /**< PostgreSQL int4 range type */ + T_INTSET = 18, /**< int4 set type */ + T_INTSPAN = 19, /**< int4 span type */ + T_INTSPANSET = 20, /**< int4 span set type */ + T_INT8 = 21, /**< int8 type */ + T_INT8MULTIRANGE = 52, /**< PostgreSQL int8 multirange type */ + T_INT8RANGE = 53, /**< PostgreSQL int8 range type */ + T_BIGINTSET = 22, /**< int8 set type */ + T_BIGINTSPAN = 23, /**< int8 span type */ + T_BIGINTSPANSET = 24, /**< int8 span set type */ + T_STBOX = 25, /**< spatiotemporal box type */ + T_TBOOL = 26, /**< temporal boolean type */ + T_TBOX = 27, /**< temporal box type */ + T_TDOUBLE2 = 28, /**< temporal double2 type */ + T_TDOUBLE3 = 29, /**< temporal double3 type */ + T_TDOUBLE4 = 30, /**< temporal double4 type */ + T_TEXT = 31, /**< text type */ + T_TEXTSET = 32, /**< text type */ + T_TFLOAT = 33, /**< temporal float type */ + T_TIMESTAMPTZ = 34, /**< timestamp with time zone type */ + T_TINT = 35, /**< temporal integer type */ + T_TSTZMULTIRANGE = 36, /**< PostgreSQL timestamp with time zone multirange type */ + T_TSTZRANGE = 37, /**< PostgreSQL timestamp with time zone range type */ + T_TSTZSET = 38, /**< timestamptz set type */ + T_TSTZSPAN = 39, /**< timestamptz span type */ + T_TSTZSPANSET = 40, /**< timestamptz span set type */ + T_TTEXT = 41, /**< temporal text type */ + T_GEOMETRY = 42, /**< geometry type */ + T_GEOMSET = 43, /**< geometry set type */ + T_GEOGRAPHY = 44, /**< geography type */ + T_GEOGSET = 45, /**< geography set type */ + T_TGEOMPOINT = 46, /**< temporal geometry point type */ + T_TGEOGPOINT = 47, /**< temporal geography point type */ + T_NPOINT = 48, /**< network point type */ + T_NPOINTSET = 49, /**< network point set type */ + T_NSEGMENT = 50, /**< network segment type */ + T_TNPOINT = 51, /**< temporal network point type */ + T_POSE = 54, /**< pose type */ + T_POSESET = 55, /**< pose set type */ + T_TPOSE = 56, /**< temporal pose type */ + T_CBUFFER = 57, /**< buffer type */ + T_CBUFFERSET = 58, /**< buffer set type */ + T_TCBUFFER = 59, /**< temporal buffer type */ + T_TGEOMETRY = 60, /**< temporal geometry type */ + T_TGEOGRAPHY = 61, /**< temporal geography type */ + T_TRGEOMETRY = 62, /**< temporal rigid geometry type */ + NUM_MEOS_TYPES /* Dummy value that determines the size of the + * lookup array MeosType -> Oid */ +} MeosType; + +/** + * Enumeration that defines the classes of Boolean operators used in + * MobilityDB. + */ +typedef enum +{ + UNKNOWN_OP = 0, + EQ_OP = 1, /**< Equality `=` operator */ + NE_OP = 2, /**< Distinct `!=` operator */ + LT_OP = 3, /**< Less than `<` operator */ + LE_OP = 4, /**< Less than or equal to `<=` operator */ + GT_OP = 5, /**< Greater than `<` operator */ + GE_OP = 6, /**< Greater than or equal to `>=` operator */ + ADJACENT_OP = 7, /**< Adjacent `-|-` operator */ + UNION_OP = 8, /**< Union `+` operator */ + MINUS_OP = 9, /**< Minus `-` operator */ + INTERSECT_OP = 10, /**< Intersection `*` operator */ + OVERLAPS_OP = 11, /**< Overlaps `&&` operator */ + CONTAINS_OP = 12, /**< Contains `@>` operator */ + CONTAINED_OP = 13, /**< Contained `<@` operator */ + SAME_OP = 14, /**< Same `~=` operator */ + LEFT_OP = 15, /**< Left `<<` operator */ + OVERLEFT_OP = 16, /**< Overleft `&<` operator */ + RIGHT_OP = 17, /**< Right `>>` operator */ + OVERRIGHT_OP = 18, /**< Overright `&>` operator */ + BELOW_OP = 19, /**< Below `<<|` operator */ + OVERBELOW_OP = 20, /**< Overbelow `&<|` operator */ + ABOVE_OP = 21, /**< Above `|>>` operator */ + OVERABOVE_OP = 22, /**< Overbove `|&>` operator */ + FRONT_OP = 23, /**< Front `<>` operator */ + OVERBACK_OP = 26, /**< Overback `/&>` operator */ + BEFORE_OP = 27, /**< Before `<<#` operator */ + OVERBEFORE_OP = 28, /**< Overbefore `&<#` operator */ + AFTER_OP = 29, /**< After `#>>` operator */ + OVERAFTER_OP = 30, /**< Overafter `#&>` operator */ + EVEREQ_OP = 31, /**< Evereq `?=` operator */ + EVERNE_OP = 32, /**< Everne `?<>` operator */ + EVERLT_OP = 33, /**< Everlt `?<` operator */ + EVERLE_OP = 34, /**< Everle `?<=` operator */ + EVERGT_OP = 35, /**< Evergt `?>` operator */ + EVERGE_OP = 36, /**< Everge `?>=` operator */ + ALWAYSEQ_OP = 37, /**< Alwayseq `%=` operator */ + ALWAYSNE_OP = 38, /**< Alwaysne `%<>` operator */ + ALWAYSLT_OP = 39, /**< Alwayslt `%<` operator */ + ALWAYSLE_OP = 40, /**< Alwaysle `%<=` operator */ + ALWAYSGT_OP = 41, /**< Alwaysgt `%>` operator */ + ALWAYSGE_OP = 42, /**< Alwaysge `%>=` operator */ +} meosOper; + +/** + * Structure to represent the temporal type cache array. + */ +typedef struct +{ + MeosType temptype; /**< Enum value of the temporal type */ + MeosType basetype; /**< Enum value of the base type */ +} temptype_catalog_struct; + +/** + * Structure to represent the span type cache array. + */ +typedef struct +{ + MeosType settype; /**< Enum value of the set type */ + MeosType basetype; /**< Enum value of the base type */ +} settype_catalog_struct; + +/** + * Structure to represent the span type cache array. + */ +typedef struct +{ + MeosType spantype; /**< Enum value of the span type */ + MeosType basetype; /**< Enum value of the base type */ +} spantype_catalog_struct; + +/** + * Structure to represent the spanset type cache array. + */ +typedef struct +{ + MeosType spansettype; /**< Enum value of the span type */ + MeosType spantype; /**< Enum value of the base type */ +} spansettype_catalog_struct; + +/*****************************************************************************/ + +#ifndef NDEBUG +extern bool temptype_subtype(tempSubtype subtype); +extern bool temptype_subtype_all(tempSubtype subtype); +#endif +extern const char *tempsubtype_name(tempSubtype subtype); +extern bool tempsubtype_from_string(const char *str, int16 *subtype); +extern const char *meosoper_name(meosOper oper); +extern meosOper meosoper_from_string(const char *name); +extern const char *interptype_name(interpType interp); +extern interpType interptype_from_string(const char *interp_str); + +/* Type conversion functions */ + +extern const char *meostype_name(MeosType type); +extern MeosType temptype_basetype(MeosType type); +extern MeosType settype_basetype(MeosType type); +extern MeosType spantype_basetype(MeosType type); +extern MeosType spantype_spansettype(MeosType type); +extern MeosType spansettype_spantype(MeosType type); +extern MeosType basetype_spantype(MeosType type); +extern MeosType basetype_settype(MeosType type); + +/* Catalog functions */ + +extern bool tnumber_basetype(MeosType type); +extern bool geo_basetype(MeosType type); +#ifndef NDEBUG +extern bool meos_basetype(MeosType type); +extern bool alphanum_basetype(MeosType type); +extern bool alphanum_temptype(MeosType type); +#endif + +extern bool time_type(MeosType type); +#ifndef NDEBUG +extern bool set_basetype(MeosType type); +#endif + +extern bool set_type(MeosType type); +extern bool numset_type(MeosType type); +extern bool ensure_numset_type(MeosType type); +extern bool timeset_type(MeosType type); +extern bool set_spantype(MeosType type); +extern bool ensure_set_spantype(MeosType type); +extern bool alphanumset_type(MeosType settype); +extern bool geoset_type(MeosType type); +extern bool ensure_geoset_type(MeosType type); +extern bool spatialset_type(MeosType type); +extern bool ensure_spatialset_type(MeosType type); + +extern bool span_basetype(MeosType type); +extern bool span_canon_basetype(MeosType type); +extern bool span_type(MeosType type); +extern bool type_span_bbox(MeosType type); +extern bool span_tbox_type(MeosType type); +extern bool ensure_span_tbox_type(MeosType type); +extern bool numspan_basetype(MeosType type); +extern bool numspan_type(MeosType type); +extern bool ensure_numspan_type(MeosType type); +extern bool timespan_basetype(MeosType type); +extern bool timespan_type(MeosType type); + +extern bool spanset_type(MeosType type); +extern bool timespanset_type(MeosType type); +extern bool ensure_timespanset_type(MeosType type); + +extern bool temporal_type(MeosType type); +#ifndef NDEBUG +extern bool temporal_basetype(MeosType type); +#endif +extern bool temptype_supports_linear(MeosType type); +extern bool basetype_byvalue(MeosType type); +extern bool basetype_varlength(MeosType type); +extern int16 meostype_length(MeosType type); +#ifndef NDEBUG +extern bool talphanum_type(MeosType type); +#endif +extern bool talpha_type(MeosType type); +extern bool tnumber_type(MeosType type); +extern bool ensure_tnumber_type(MeosType type); +extern bool ensure_tnumber_basetype(MeosType type); +extern bool tnumber_spantype(MeosType type); +extern bool spatial_basetype(MeosType type); +extern bool tspatial_type(MeosType type); +extern bool ensure_tspatial_type(MeosType type); +extern bool tpoint_type(MeosType type); +extern bool ensure_tpoint_type(MeosType type); +extern bool tgeo_type(MeosType type); +extern bool ensure_tgeo_type(MeosType type); +extern bool tgeo_type_all(MeosType type); +extern bool ensure_tgeo_type_all(MeosType type); +extern bool tgeometry_type(MeosType type); +extern bool ensure_tgeometry_type(MeosType type); +extern bool tgeodetic_type(MeosType type); +extern bool ensure_tgeodetic_type(MeosType type); +extern bool ensure_tnumber_tpoint_type(MeosType type); + +/*****************************************************************************/ + +#endif /* __MEOS_CATALOG_H__ */ + diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/postgres_types.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/postgres_types.h new file mode 100644 index 0000000..7c671ab --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/postgres_types.h @@ -0,0 +1,114 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for base and time types corresponding to external + * PostgreSQL functions in order to bypass the function manager @p fmgr.c. + */ + +#ifndef POSTGRES_TYPES_H +#define POSTGRES_TYPES_H + +/* PostgreSQL */ +#include +#if MEOS +#include "postgres_int_defs.h" +#else +#include +#include +#endif /* MEOS */ + +#if POSTGRESQL_VERSION_NUMBER < 170000 +/* + * Infinite intervals are represented by setting all fields to the minimum or + * maximum integer values. + */ +#define INTERVAL_NOBEGIN(i) \ + do { \ + (i)->time = PG_INT64_MIN; \ + (i)->day = PG_INT32_MIN; \ + (i)->month = PG_INT32_MIN; \ + } while (0) + +#define INTERVAL_IS_NOBEGIN(i) \ + ((i)->month == PG_INT32_MIN && (i)->day == PG_INT32_MIN && (i)->time == PG_INT64_MIN) + +#define INTERVAL_NOEND(i) \ + do { \ + (i)->time = PG_INT64_MAX; \ + (i)->day = PG_INT32_MAX; \ + (i)->month = PG_INT32_MAX; \ + } while (0) + +#define INTERVAL_IS_NOEND(i) \ + ((i)->month == PG_INT32_MAX && (i)->day == PG_INT32_MAX && (i)->time == PG_INT64_MAX) + +#define INTERVAL_NOT_FINITE(i) (INTERVAL_IS_NOBEGIN(i) || INTERVAL_IS_NOEND(i)) +#endif /* POSTGRESQL_VERSION_NUMBER < 170000 */ + +/* Functions adapted from int.c */ + +extern int32 int4_in(const char *str); +extern char *int4_out(int32 val); + +/* Functions adapted from int8.c */ + +extern int64 int8_in(const char *str); +extern char *int8_out(int64 val); + +/* Functions adapted from float.c */ + +extern float8 float8_in(const char *num, const char *type_name, + const char *orig_string); +extern char *float8_out(double num, int maxdd); +extern float8 pg_dsin(float8 arg1); +extern float8 pg_dcos(float8 arg1); +extern float8 pg_datan(float8 arg1); +extern float8 pg_datan2(float8 arg1, float8 arg2); + +/* Functions adadpted from timestamp.c */ + +extern Interval *interval_negate(const Interval *interval); +extern Interval *pg_interval_justify_hours(const Interval *span); + +/* Functions adapted from hashfn.h and hashfn.c */ + +extern uint32 hash_bytes_uint32(uint32 k); +extern uint32 pg_hashint8(int64 val); +extern uint32 pg_hashfloat8(float8 key); +extern uint64 hash_bytes_uint32_extended(uint32 k, uint64 seed); +extern uint64 pg_hashint8extended(int64 val, uint64 seed); +extern uint64 pg_hashfloat8extended(float8 key, uint64 seed); +extern uint32 pg_hashtext(text *key); +extern uint64 pg_hashtextextended(text *key, uint64 seed); + +/*****************************************************************************/ + +#endif /* POSTGRES_TYPES_H */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/set.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/set.h new file mode 100644 index 0000000..3a5bf71 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/set.h @@ -0,0 +1,95 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for set of (distinct) timestamps. + */ + +#ifndef __SET_H__ +#define __SET_H__ + +/*****************************************************************************/ + +/* + * fmgr macros for ordered set types + */ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" +#include "temporal/temporal.h" + +#if MEOS + #define DatumGetSetP(X) ((Set *) DatumGetPointer(X)) +#else + #define DatumGetSetP(X) ((Set *) PG_DETOAST_DATUM(X)) +#endif /* MEOS */ +#define SetPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_SET_P(X) ((Set *) PG_GETARG_VARLENA_P(X)) +#define PG_RETURN_SET_P(X) PG_RETURN_POINTER(X) + +#define MINIDX 0 +#define MAXIDX count - 1 + +/***************************************************************************** + * Struct definition for the unnest operation + *****************************************************************************/ + +/** + * Structure to represent information about an entry that can be placed + * to either group without affecting overlap over selected axis ("common entry"). + */ +typedef struct +{ + bool done; + int i; + int count; + Set *set; /* Set to unnest */ + Datum *values; /* Values obtained by getValues(temp) */ +} SetUnnestState; + +/*****************************************************************************/ + +/* General functions */ + +extern char *set_out_fn(const Set *s, int maxdd, outfunc value_out); + +extern bool ensure_set_isof_type(const Set *s, MeosType settype); +extern bool ensure_valid_set_set(const Set *s1, const Set *s2); + +extern bool set_find_value(const Set *s, Datum, int *loc); + +extern SetUnnestState *set_unnest_state_make(const Set *set); +extern void set_unnest_state_next(SetUnnestState *state); + +/*****************************************************************************/ + +#endif /* __SET_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/skiplist.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/skiplist.h new file mode 100644 index 0000000..546c5ba --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/skiplist.h @@ -0,0 +1,62 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Skiplist data structure used for performing temporal aggregates + */ + +#ifndef __SKIPLIST_H__ +#define __SKIPLIST_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/***************************************************************************** + * fmgr macros + *****************************************************************************/ + +#define DatumGetSkipListP(X) ((SkipList *) DatumGetPointer(X)) +#define SkipListPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_SKIPLIST_P(n) DatumGetSkipListP(PG_GETARG_DATUM(n)) +#define PG_RETURN_SKIPLIST_P(x) return SkipListPGetDatum(x) + +/*****************************************************************************/ + +extern bool ensure_same_skiplist_subtype(SkipList *state, uint8 subtype); + +extern void skiplist_set_extra(SkipList *state, void *data, size_t size); +extern void *skiplist_headval(SkipList *list); + + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span.h new file mode 100644 index 0000000..c38c66e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span.h @@ -0,0 +1,117 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic routines for spans (a.k.a. ranges) composed of two `Datum` + * values and two Boolean values stating whether the bounds are inclusive. + */ + +#ifndef __SPAN_H__ +#define __SPAN_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/** + * Internal representation of either bound of a span (not what's on disk) + */ +typedef struct +{ + Datum val; /**< bound value */ + bool inclusive; /**< bound is inclusive (vs exclusive) */ + bool lower; /**< this is the lower (vs upper) bound */ + uint8 spantype; /**< span type */ + uint8 basetype; /**< span basetype */ +} SpanBound; + +/* + * fmgr macros for span types + */ + +#define DatumGetSpanP(X) ((Span *) DatumGetPointer(X)) +#define SpanPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_SPAN_P(X) DatumGetSpanP(PG_GETARG_DATUM(X)) +#define PG_RETURN_SPAN_P(X) PG_RETURN_POINTER(X) + +#if MEOS + #define DatumGetSpanSetP(X) ((SpanSet *) DatumGetPointer(X)) +#else + #define DatumGetSpanSetP(X) ((SpanSet *) PG_DETOAST_DATUM(X)) +#endif /* MEOS */ +#define SpanSetPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_SPANSET_P(X) ((SpanSet *) PG_GETARG_VARLENA_P(X)) +#define PG_RETURN_SPANSET_P(X) PG_RETURN_POINTER(X) + +/*****************************************************************************/ + +/* General functions */ + +extern bool ensure_span_isof_type(const Span *s, MeosType spantype); +extern bool ensure_span_isof_basetype(const Span *s, MeosType basetype); +extern bool ensure_same_span_type(const Span *s1, const Span *s2); +extern bool ensure_valid_span_span(const Span *s1, const Span *s2); + +extern void span_deserialize(const Span *s, SpanBound *lower, + SpanBound *upper); +extern int span_bound_cmp(const SpanBound *b1, const SpanBound *b2); +extern int span_bound_qsort_cmp(const void *s1, const void *s2); +extern int span_lower_cmp(const Span *s1, const Span *s2); +extern int span_upper_cmp(const Span *s1, const Span *s2); +extern Datum span_decr_bound(Datum upper, MeosType basetype); +extern Datum span_incr_bound(Datum upper, MeosType basetype); +extern Span *spanarr_normalize(Span *spans, int count, bool sort, + int *newcount); +extern void span_bounds_shift_scale_value(Datum shift, Datum width, + MeosType type, bool hasshift, bool haswidth, Datum *lower, Datum *upper); +extern void span_bounds_shift_scale_time(const Interval *shift, + const Interval *duration, TimestampTz *lower, TimestampTz *upper); +extern void floatspan_floor_ceil_iter(Span *s, datum_func1 func); +extern void numspan_delta_scale_iter(Span *s, Datum origin, Datum delta, + bool hasdelta, double scale); +extern void tstzspan_delta_scale_iter(Span *s, TimestampTz origin, + TimestampTz delta, double scale); +extern void numspan_shift_scale_iter(Span *s, Datum shift, Datum width, + bool hasshift, bool haswidth, Datum *delta, double *scale); +extern void tstzspan_shift_scale1(Span *s, const Interval *shift, + const Interval *duration, TimestampTz *delta, double *scale); + +extern int mi_span_span(const Span *s1, const Span *s2, Span *result); +extern int mi_span_value(const Span *s, Datum value, Span *result); + +extern double dist_double_value_value(Datum l, Datum r, MeosType type); + +/*****************************************************************************/ + +#endif /* __SPAN_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span_index.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span_index.h new file mode 100644 index 0000000..7f91674 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/span_index.h @@ -0,0 +1,56 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic routines for indexing spans + */ + +#ifndef __SPAN_INDEX_H__ +#define __SPAN_INDEX_H__ + +/* PostgreSQL */ +#include +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern int common_entry_cmp(const void *i1, const void *i2); + +extern bool span_index_leaf_consistent(const Span *key, const Span *query, + StrategyNumber strategy); +extern bool span_gist_inner_consistent(const Span *key, const Span *query, + StrategyNumber strategy); +extern bool span_index_recheck(StrategyNumber strategy); + +/*****************************************************************************/ + +#endif /* __SPAN_INDEX_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/spanset.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/spanset.h new file mode 100644 index 0000000..c0bae9a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/spanset.h @@ -0,0 +1,58 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for set of disjoint spans. + */ + +#ifndef __SPANSET_H__ +#define __SPANSET_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/* General functions */ + +extern bool ensure_spanset_isof_type(const SpanSet *ss, MeosType spansettype); +extern bool ensure_same_spanset_type(const SpanSet *ss1, const SpanSet *ss2); +extern bool ensure_same_spanset_span_type(const SpanSet *ss, const Span *s); +extern bool ensure_valid_spanset_span(const SpanSet *ss, const Span *s); +extern bool ensure_valid_spanset_spanset(const SpanSet *ss1, + const SpanSet *ss2); + +extern bool spanset_find_value(const SpanSet *ss, Datum v, int *loc); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/stratnum.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/stratnum.h new file mode 100644 index 0000000..8fd50ef --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/stratnum.h @@ -0,0 +1,105 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Strategy numbers for MEOS indexes + * @note Definitions borrowed from startnum.h + */ + +#ifndef __STRATNUM_H__ +#define __STRATNUM_H__ + +/* PostgreSQL */ +#include + +/*****************************************************************************/ + +#if ! MEOS +/* + * Strategy numbers identify the semantics that particular operators have + * with respect to particular operator classes. In some cases a strategy + * subtype (an OID) is used as further information. + */ +typedef uint16 StrategyNumber; + +#define InvalidStrategy ((StrategyNumber) 0) + +/* + * Strategy numbers common to (some) GiST, SP-GiST and BRIN opclasses. + * + * The first few of these come from the R-Tree indexing method (hence the + * names); the others have been added over time as they have been needed. + */ +#define RTLeftStrategyNumber 1 /* for << */ +#define RTOverLeftStrategyNumber 2 /* for &< */ +#define RTOverlapStrategyNumber 3 /* for && */ +#define RTOverRightStrategyNumber 4 /* for &> */ +#define RTRightStrategyNumber 5 /* for >> */ +#define RTSameStrategyNumber 6 /* for ~= */ +#define RTContainsStrategyNumber 7 /* for @> */ +#define RTContainedByStrategyNumber 8 /* for <@ */ +#define RTOverBelowStrategyNumber 9 /* for &<| */ +#define RTBelowStrategyNumber 10 /* for <<| */ +#define RTAboveStrategyNumber 11 /* for |>> */ +#define RTOverAboveStrategyNumber 12 /* for |&> */ +#define RTOldContainsStrategyNumber 13 /* for old spelling of @> */ +#define RTOldContainedByStrategyNumber 14 /* for old spelling of <@ */ +#define RTKNNSearchStrategyNumber 15 /* for <-> (distance) */ +#define RTContainsElemStrategyNumber 16 /* for range types @> elem */ +#define RTAdjacentStrategyNumber 17 /* for -|- */ +#define RTEqualStrategyNumber 18 /* for = */ +#define RTNotEqualStrategyNumber 19 /* for != */ +#define RTLessStrategyNumber 20 /* for < */ +#define RTLessEqualStrategyNumber 21 /* for <= */ +#define RTGreaterStrategyNumber 22 /* for > */ +#define RTGreaterEqualStrategyNumber 23 /* for >= */ +#define RTSubStrategyNumber 24 /* for inet >> */ +#define RTSubEqualStrategyNumber 25 /* for inet <<= */ +#define RTSuperStrategyNumber 26 /* for inet << */ +#define RTSuperEqualStrategyNumber 27 /* for inet >>= */ +#define RTPrefixStrategyNumber 28 /* for text ^@ */ +#define RTOldBelowStrategyNumber 29 /* for old spelling of <<| */ +#define RTOldAboveStrategyNumber 30 /* for old spelling of |>> */ + +#endif /* ! MEOS */ + +/* Additional operator strategy numbers used for temporal types */ + +#define RTOverBeforeStrategyNumber 28 /* for &<# */ +#define RTBeforeStrategyNumber 29 /* for <<# */ +#define RTAfterStrategyNumber 30 /* for #>> */ +#define RTOverAfterStrategyNumber 31 /* for #&> */ +#define RTOverFrontStrategyNumber 32 /* for &> */ +#define RTOverBackStrategyNumber 35 /* for /&> */ + +/*****************************************************************************/ + +#endif /* __STRATNUM_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbool_ops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbool_ops.h new file mode 100644 index 0000000..ed0a7cb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbool_ops.h @@ -0,0 +1,55 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal Boolean operators (and, or, not). + */ + +#ifndef __TBOOL_BOOLOPS_H__ +#define __TBOOL_BOOLOPS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern Datum datum_and(Datum l, Datum r); +extern Datum datum_or(Datum l, Datum r); + +extern Temporal *boolop_tbool_bool(const Temporal *temp, Datum b, + datum_func2 func, bool invert); +extern Temporal *boolop_tbool_tbool(const Temporal *temp1, + const Temporal *temp2, datum_func2 func); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox.h new file mode 100644 index 0000000..305d99c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox.h @@ -0,0 +1,67 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for temporal bounding boxes. + */ + +#ifndef __TBOX_H__ +#define __TBOX_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include + +/*****************************************************************************/ + +/* fmgr macros temporal types */ + +#define DatumGetTboxP(X) ((TBox *) DatumGetPointer(X)) +#define TboxPGetDatum(X) PointerGetDatum(X) +#define PG_GETARG_TBOX_P(n) DatumGetTboxP(PG_GETARG_DATUM(n)) +#define PG_RETURN_TBOX_P(x) return TboxPGetDatum(x) + +/*****************************************************************************/ + +/* Parameter tests */ + +extern bool ensure_same_dimensionality_tbox(const TBox *box1, const TBox *box2); + +/* Conversion */ + +extern TBox *set_tbox(const Set *s); +extern TBox *span_tbox(const Span *s); +extern Span *tbox_tstzspan(const TBox *box); +extern Span *tbox_intspan(const TBox *box); +extern Span *tbox_floatspan(const TBox *box); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox_index.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox_index.h new file mode 100644 index 0000000..44bee07 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tbox_index.h @@ -0,0 +1,54 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic routines for indexing temporal values + */ + +#ifndef __TBOX_INDEX_H__ +#define __TBOX_INDEX_H__ + +/* PostgreSQL */ +#include +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern bool tbox_index_leaf_consistent(const TBox *key, const TBox *query, + StrategyNumber strategy); +extern bool tbox_gist_inner_consistent(const TBox *key, const TBox *query, + StrategyNumber strategy); +extern bool tbox_index_recheck(StrategyNumber strategy); + +/*****************************************************************************/ + +#endif /* __TBOX_INDEX_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal.h new file mode 100644 index 0000000..ceff737 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal.h @@ -0,0 +1,444 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for temporal types of any subtype. + */ + +#ifndef __TEMPORAL_H__ +#define __TEMPORAL_H__ + +/* PostgreSQL */ +#include +#if POSTGRESQL_VERSION_NUMBER >= 160000 + #include "varatt.h" +#endif +/* MEOS */ +#include +#include +#include +#include "temporal/doublen.h" +#include "temporal/meos_catalog.h" + +/* To avoid including pg_collation_d */ +#define DEFAULT_COLLATION_OID 100 +#define C_COLLATION_OID 950 +#define POSIX_COLLATION_OID 951 + +#ifndef FMGR_H + /* To avoid including fmgr.h However this implies that the text values must + * be ALWAYS detoasted */ + #define DatumGetTextP(X) ((text *) DatumGetPointer(X)) // ((text *) PG_DETOAST_DATUM(X)) +#endif /* FMGR_H */ + +/** + * Floating point precision + */ +#define MEOS_EPSILON 1.0e-06 +#define MEOS_FP_EQ(A, B) (fabs((A)-(B)) <= MEOS_EPSILON) +#define MEOS_FP_NE(A, B) (fabs((A)-(B)) > MEOS_EPSILON) +#define MEOS_FP_LT(A, B) (((A) + MEOS_EPSILON) < (B)) +#define MEOS_FP_LE(A, B) (((A) - MEOS_EPSILON) <= (B)) +#define MEOS_FP_GT(A, B) (((A) - MEOS_EPSILON) > (B)) +#define MEOS_FP_GE(A, B) (((A) + MEOS_EPSILON) >= (B)) + +/** + * Precision for distance operations + */ +#define DIST_EPSILON 1.0e-06 + +#define UNUSED __attribute__((unused)) + +/** Symbolic constants for lifting */ +#define DISCONTINUOUS true +#define CONTINUOUS false + +/** Symbolic constants for sets and for normalizing spans */ +#define ORDER true +#define ORDER_NO false + +/** Symbolic constants for the output of string elements */ +#define QUOTES true +#define QUOTES_NO false + +/** Symbolic constants for the output of string elements */ +#define SPACES true +#define SPACES_NO false + +/** Symbolic constants for lifting */ +#define INVERT true +#define INVERT_NO false + +/** Symbolic constants for the restriction functions */ +#define REST_AT true +#define REST_MINUS false + +/** Symbolic constants for the restriction functions with boxes */ +#define BORDER_INC true +#define BORDER_EXC false + +/** Symbolic constants for the ever/always functions */ +#define EVER true +#define ALWAYS false + +/** Symbolic constants for the temporal point/geo functions */ +#define TPOINT true +#define TGEO false + +/** Symbolic constants for the restriction and the aggregation functions */ +#define GET_MIN true +#define GET_MAX false + +/** Symbolic constants for the synchronization and the aggregation functions */ +#define CROSSINGS true +#define CROSSINGS_NO false + +/** Symbolic constants for the synchronization and the aggregation functions */ +#define BBOX_TEST true +#define BBOX_TEST_NO false + +/** Symbolic constants for the make functions */ +#define MERGE true +#define MERGE_NO false + +#define NORMALIZE true +#define NORMALIZE_NO false + +/** Symbolic constants for spatial relationships */ +#define WITH_Z true +#define NO_Z false + +/** Symbolic constants for the span selectivity functions */ +#define VALUE_SEL true +#define TIME_SEL false + +/** Symbolic constants for the restriction functions */ +#define UPPER_EXC true +#define TIME_SEL false + +/** Symbolic constants for trajectory function */ +#define UNARY_UNION true +#define UNARY_UNION_NO false + +/** Enumeration for the intersection/synchronization functions */ +typedef enum +{ + SYNCHRONIZE_NOCROSS, + SYNCHRONIZE_CROSS, +} SyncMode; + +/** Enumeration for the families of temporal types */ +typedef enum +{ + TEMPORALTYPE, + TNUMBERTYPE, + TSPATIALTYPE, +} TemporalFamily; + +/** Enumeration for the set operations of span and temporal types */ +typedef enum +{ + UNION, + INTER, + MINUS +} SetOper; + +/** Enumeration for the comparison operations */ +typedef enum +{ + EQ, + NE, + LT, + LE, + GT, + GE +} CompOper; + +/* PostgreSQL removed pg_atoi in version 15 */ +#if POSTGRESQL_VERSION_NUMBER >= 150000 + extern int32 pg_strtoint32(const char *s); +#else + /* To avoid including */ + extern int32 pg_atoi(const char *s, int size, int c); +#endif /* POSTGRESQL_VERSION_NUMBER >= 150000 */ + +/***************************************************************************** + * Additional operator strategy numbers used in the GiST and SP-GiST temporal + * opclasses with respect to those defined in the file stratnum.h + *****************************************************************************/ + +#define RTOverBeforeStrategyNumber 28 /* for &<# */ +#define RTBeforeStrategyNumber 29 /* for <<# */ +#define RTAfterStrategyNumber 30 /* for #>> */ +#define RTOverAfterStrategyNumber 31 /* for #&> */ +#define RTOverFrontStrategyNumber 32 /* for &> */ +#define RTOverBackStrategyNumber 35 /* for /&> */ + +/***************************************************************************** + * Well-Known Binary (WKB) + *****************************************************************************/ + +/* Data type size */ +#define MEOS_WKB_BYTE_SIZE 1 +#define MEOS_WKB_INT2_SIZE 2 +#define MEOS_WKB_INT4_SIZE 4 +#define MEOS_WKB_INT8_SIZE 8 +#define MEOS_WKB_DOUBLE_SIZE 8 +#define MEOS_WKB_DATE_SIZE 4 +#define MEOS_WKB_TIMESTAMP_SIZE 8 + +/* Temporal subtype */ +enum MEOS_WKB_TSUBTYPE +{ + MEOS_WKB_TINSTANT = 1, /**< temporal instant subtype */ + MEOS_WKB_TSEQUENCE = 2, /**< temporal sequence subtype */ + MEOS_WKB_TSEQUENCESET = 3, /**< temporal sequence set subtype */ +}; + +/* Span bounds */ +#define MEOS_WKB_LOWER_INC 0x01 +#define MEOS_WKB_UPPER_INC 0x02 + +/* Machine endianness */ +#define XDR 0 /* big endian */ +#define NDR 1 /* little endian */ + +/* Variation flags + * The first byte of the variation flag depends on the type we are sending + * - Set types: xxxO where O states whether the set is ordered or not + * - Box types: xxTX where X and T state whether the corresponding dimensions + * are present + * - Temporal types: xxSS where SS correspond to the subtype + * and x are unused bits + */ +#define MEOS_WKB_ORDERED 0x01 // 1 +#define MEOS_WKB_XFLAG 0x01 // 1 +#define MEOS_WKB_TFLAG 0x02 // 2 +#define MEOS_WKB_INTERPFLAGS 0x0C // 4 + 8 +#define MEOS_WKB_ZFLAG 0x10 // 16 +#define MEOS_WKB_GEODETICFLAG 0x20 // 32 +#define MEOS_WKB_SRIDFLAG 0x40 // 64 + +#define MEOS_WKB_GET_INTERP(flags) (((flags) & MEOS_WKB_INTERPFLAGS) >> 2) +#define MEOS_WKB_SET_INTERP(flags, value) ((flags) = (((flags) & ~MEOS_WKB_INTERPFLAGS) | ((value & 0x0003) << 2))) + +// #define MEOS_WKB_GET_LINEAR(flags) ((bool) (((flags) & MEOS_WKB_LINEARFLAG)>>3)) + +/***************************************************************************** + * Definitions for binning and tiling + *****************************************************************************/ + +/* + * The default origin is Monday 2000-01-03. We don't use PG epoch since it + * starts on a Saturday. This makes time bins by a week more intuitive and + * aligns it with date_trunc. + */ +#define JAN_3_2000 (2 * USECS_PER_DAY) +#define DEFAULT_TIME_ORIGIN (JAN_3_2000) +#define DEFAULT_FLOATSPAN_ORIGIN (0.0) +#define DEFAULT_INTSPAN_ORIGIN (0) +#define DEFAULT_BIGINTSPAN_ORIGIN (0) + +/***************************************************************************** + * Additional struct definitions for temporal types + *****************************************************************************/ + +/** + * Structure to represent all types of bounding boxes + */ +typedef union bboxunion +{ + Span p; /**< Span */ + TBox b; /**< Temporal box */ + STBox g; /**< Spatiotemporal box */ +} bboxunion; + +/***************************************************************************** + * Miscellaneous + *****************************************************************************/ + +/* Definition of output function */ +typedef char *(*outfunc)(Datum value, MeosType type, int maxdd); + +/* Definition of qsort comparator for integers */ +typedef int (*qsort_comparator) (const void *a, const void *b); + +/* Definition of a variadic function type for temporal lifting */ +typedef Datum (*varfunc) (Datum, ...); + +/* Definition of a turning point function for a unary temporal lift */ +typedef int (*tpfunc_unary)(Datum, Datum, TimestampTz, TimestampTz, + TimestampTz *, TimestampTz *); + +/* Definition of a turning point function for a temporal and a base types */ +typedef int (*tpfunc_base)(Datum, Datum, Datum, TimestampTz, TimestampTz, + TimestampTz *, TimestampTz *); + +/* Definition of a turning point function for two temporal types */ +typedef int (*tpfunc_temp)(Datum, Datum, Datum, Datum, Datum, TimestampTz, + TimestampTz, TimestampTz *, TimestampTz *); + +/***************************************************************************** + * fmgr macros temporal types + *****************************************************************************/ + +/* doubleN */ + +#define DatumGetDouble2P(X) ((double2 *) DatumGetPointer(X)) +#define Double2PGetDatum(X) PointerGetDatum(X) +#define DatumGetDouble3P(X) ((double3 *) DatumGetPointer(X)) +#define Double3PGetDatum(X) PointerGetDatum(X) +#define DatumGetDouble4P(X) ((double4 *) DatumGetPointer(X)) +#define Double4PGetDatum(X) PointerGetDatum(X) + +/* Temporal types */ + +#if MEOS + #define DatumGetTemporalP(X) ((Temporal *) DatumGetPointer(X)) + #define DatumGetTInstantP(X) ((TInstant *) DatumGetPointer(X)) + #define DatumGetTSequenceP(X) ((TSequence *) DatumGetPointer(X)) + #define DatumGetTSequenceSetP(X) ((TSequenceSet *) DatumGetPointer(X)) +#else + #define DatumGetTemporalP(X) ((Temporal *) PG_DETOAST_DATUM(X)) + #define DatumGetTInstantP(X) ((TInstant *) PG_DETOAST_DATUM(X)) + #define DatumGetTSequenceP(X) ((TSequence *) PG_DETOAST_DATUM(X)) + #define DatumGetTSequenceSetP(X) ((TSequenceSet *) PG_DETOAST_DATUM(X)) +#endif /* MEOS */ + +#define PG_GETARG_TEMPORAL_P(X) ((Temporal *) PG_GETARG_VARLENA_P(X)) +#define PG_GETARG_TINSTANT_P(X) ((TInstant *) PG_GETARG_VARLENA_P(X)) +#define PG_GETARG_TSEQUENCE_P(X) ((TSequence *) PG_GETARG_VARLENA_P(X)) +#define PG_GETARG_TSEQUENCESET_P(X) ((TSequenceSet *) PG_GETARG_VARLENA_P(X)) + +#define PG_RETURN_TEMPORAL_P(X) PG_RETURN_POINTER(X) +#define PG_RETURN_TINSTANT_P(X) PG_RETURN_POINTER(X) +#define PG_RETURN_TSEQUENCE_P(X) PG_RETURN_POINTER(X) +#define PG_RETURN_TSEQUENCESET_P(X) PG_RETURN_POINTER(X) + +#define TemporalPGetDatum(X) PointerGetDatum(X) +#define TInstantPGetDatum(X) PointerGetDatum(X) +#define TSequencePGetDatum(X) PointerGetDatum(X) +#define TSequenceSetPGetDatum(X) PointerGetDatum(X) + +#define DATUM_FREE(value, basetype) \ + do { \ + if (! basetype_byvalue(basetype)) \ + pfree(DatumGetPointer(value)); \ + } while (0) + +#define DATUM_FREE_IF_COPY(value, basetype, n) \ + do { \ + if (! basetype_byvalue(basetype) && DatumGetPointer(value) != PG_GETARG_POINTER(n)) \ + pfree(DatumGetPointer(value)); \ + } while (0) + +/** + * This macro is based on PG_FREE_IF_COPY, except that it accepts two pointers. + * See PG_FREE_IF_COPY comment in src/include/fmgr.h in postgres source code + * for more details. + * This macro is the same as POSTGIS_FREE_IF_COPY_P. + */ +#define PG_FREE_IF_COPY_P(ptrsrc, ptrori) \ + do { \ + if ((Pointer) (ptrsrc) != (Pointer) (ptrori)) \ + pfree(ptrsrc); \ + } while (0) + +#define PG_DATUM_NEEDS_DETOAST(datum) \ + (VARATT_IS_EXTENDED((datum)) || VARATT_IS_EXTERNAL((datum)) || \ + VARATT_IS_COMPRESSED((datum))) + +/*****************************************************************************/ + +/* Parameter tests */ + +extern bool ensure_has_X(MeosType type, int16 flags); +extern bool ensure_has_Z(MeosType type, int16 flags); +extern bool ensure_has_T(MeosType type, int16 flags); +extern bool ensure_has_not_Z(MeosType type, int16 flags); +extern bool ensure_not_null(void *ptr); +extern bool ensure_one_not_null(void *ptr1, void *ptr2); +extern bool ensure_one_true(bool hasshift, bool haswidth); +extern bool ensure_valid_interp(MeosType temptype, interpType interp); +extern bool ensure_continuous(const Temporal *temp); +extern bool ensure_same_interp(const Temporal *temp1, const Temporal *temp2); +extern bool ensure_same_continuous_interp(int16 flags1, int16 flags2); +extern bool ensure_linear_interp(int16 flags); +extern bool ensure_nonlinear_interp(int16 flags); +extern bool ensure_common_dimension(int16 flags1, int16 flags2); +extern bool ensure_temporal_isof_type(const Temporal *temp, MeosType type); +extern bool ensure_temporal_isof_basetype(const Temporal *temp, + MeosType basetype); +extern bool ensure_temporal_isof_subtype(const Temporal *temp, + tempSubtype type); +extern bool ensure_same_temporal_type(const Temporal *temp1, + const Temporal *temp2); + +extern bool ensure_valid_tnumber_numspan(const Temporal *temp, const Span *s); +extern bool ensure_valid_tnumber_numspanset(const Temporal *temp, + const SpanSet *ss); +extern bool ensure_valid_tnumber_tbox(const Temporal *temp, const TBox *box); +extern bool ensure_valid_temporal_set(const Temporal *temp, const Set *s); +extern bool ensure_valid_temporal_temporal(const Temporal *temp1, const Temporal *temp2); +extern bool ensure_valid_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2); +extern bool ensure_not_negative(int i); +extern bool ensure_positive(int i); +extern bool not_negative_datum(Datum size, MeosType basetype); +extern bool ensure_not_negative_datum(Datum size, MeosType basetype); +extern bool positive_datum(Datum size, MeosType basetype); +extern bool ensure_positive_datum(Datum size, MeosType basetype); +extern bool ensure_valid_day_duration(const Interval *duration); +extern bool positive_duration(const Interval *duration); +extern bool ensure_positive_duration(const Interval *duration); + +/* General functions */ + +extern void *temporal_bbox_ptr(const Temporal *temp); + +extern bool intersection_temporal_temporal(const Temporal *temp1, +const Temporal *temp2, SyncMode mode, Temporal **inter1, Temporal **inter2); + +/* Version functions */ + +extern char *mobilitydb_version(void); +extern char *mobilitydb_full_version(void); + +/* Transformations */ + +extern datum_func2 round_fn(MeosType basetype); + +/* Restriction functions */ + +extern bool temporal_bbox_restrict_value(const Temporal *temp, Datum value); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_aggfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_aggfuncs.h new file mode 100644 index 0000000..10812a9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_aggfuncs.h @@ -0,0 +1,102 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal aggregate functions + */ + +#ifndef __TEMPORAL_AGGFUNCS_H__ +#define __TEMPORAL_AGGFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern Datum datum_min_int32(Datum l, Datum r); +extern Datum datum_max_int32(Datum l, Datum r); +extern Datum datum_min_float8(Datum l, Datum r); +extern Datum datum_max_float8(Datum l, Datum r); +extern Datum datum_sum_int32(Datum l, Datum r); +extern Datum datum_sum_float8(Datum l, Datum r); +extern Datum datum_min_text(Datum l, Datum r); +extern Datum datum_max_text(Datum l, Datum r); +extern Datum datum_sum_double2(Datum l, Datum r); +extern Datum datum_sum_double3(Datum l, Datum r); +extern Datum datum_sum_double4(Datum l, Datum r); + +/* Specific skiplist functions for temporal aggregations */ + +extern int temporal_skiplist_common(SkipList *list, void **values, int count, + int *lower, int *upper, int update[SKIPLIST_MAXLEVEL]); +extern void **temporal_skiplist_merge(void **spliced, int spliced_count, + void **values, int count, datum_func2 func, bool crossings, int *newcount, + void ***tofree, int *nfree); +extern void temporal_skiplist_splice(SkipList *list, void **values, int count, + datum_func2 func, bool crossings); + +/* Generic aggregation functions */ + +extern TInstant **tinstant_tagg(TInstant **instants1, int count1, + TInstant **instants2, int count2, datum_func2 func, int *newcount, + void ***tofree, int *nfree); +extern TSequence **tsequence_tagg(TSequence **sequences1, int count1, + TSequence **sequences2, int count2, datum_func2 func, bool crossings, + int *newcount); +extern SkipList *tcontseq_tagg_transfn(SkipList *state, const TSequence *seq, + datum_func2 func, bool interpoint); +extern SkipList *temporal_tagg_combinefn(SkipList *state1, SkipList *state2, + datum_func2 func, bool crossings); + +extern SkipList *tinstant_tagg_transfn(SkipList *state, const TInstant *inst, + datum_func2 func); +extern TSequence *tinstant_tavg_finalfn(TInstant **instants, int count); +extern TSequenceSet *tsequence_tavg_finalfn(TSequence **sequences, int count); +extern TInstant *tnumberinst_transform_tavg(const TInstant *inst); +extern Temporal **temporal_transform_tcount(const Temporal *temp, int *count); +extern Temporal **temporal_transform_tagg(const Temporal *temp, int *count, + TInstant *(*func)(const TInstant *)); +extern SkipList *tsequenceset_tagg_transfn(SkipList *state, + const TSequenceSet *ss, datum_func2 func, bool crossings); +extern SkipList *tdiscseq_tagg_transfn(SkipList *state, const TSequence *seq, + datum_func2 func); + +extern SkipList *temporal_tagg_transfn(SkipList *state, const Temporal *temp, + datum_func2, bool crossings); +extern SkipList *temporal_tagg_combinefn(SkipList *state1, SkipList *state2, + datum_func2 func, bool crossings); +extern SkipList *temporal_tagg_transform_transfn(SkipList *state, const Temporal *temp, + datum_func2 func, bool crossings, TInstant *(*transform)(const TInstant *)); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_analytics.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_analytics.h new file mode 100644 index 0000000..8c4374e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_analytics.h @@ -0,0 +1,67 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +#ifndef __TEMPORAL_ANALYTICS_H__ +#define __TEMPORAL_ANALYTICS_H__ + +/* MEOS */ +#include + +/*****************************************************************************/ + +typedef enum +{ + FRECHET, + DYNTIMEWARP, + HAUSDORFF +} SimFunc; + +/** + * Struct for storing the state that persists across multiple calls generating + * the path + */ +typedef struct +{ + bool done; + int i; + int size; + Match *path; +} SimilarityPathState; + +/*****************************************************************************/ + +extern double temporal_similarity(const Temporal *temp1, const Temporal *temp2, + SimFunc simfunc); +extern Match *temporal_similarity_path(const Temporal *temp1, + const Temporal *temp2, int *count, SimFunc simfunc); + +/*****************************************************************************/ + +#endif /* __TEMPORAL_ANALYTICS_H__ */ + diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_boxops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_boxops.h new file mode 100644 index 0000000..9145a4c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_boxops.h @@ -0,0 +1,82 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Bounding box operators for temporal types. + */ + +#ifndef __TEMPORAL_BOXOPS_H__ +#define __TEMPORAL_BOXOPS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/** + * @brief Return the size in bytes to read from toast to get the basic + * information from a temporal: Temporal struct (i.e., TInstant, TSequence, + * or TSequenceSet) and bounding box size +*/ +#define TEMPORAL_MAX_HEADER_SIZE \ + DOUBLE_PAD(Max(Max(sizeof(TInstant), sizeof(TSequence)), \ + sizeof(TSequenceSet))) + DOUBLE_PAD(sizeof(bboxunion)) + +/*****************************************************************************/ + +/* Compute the bounding box at the creation of temporal values */ + +extern size_t temporal_bbox_size(MeosType tempype); +extern void tinstant_set_bbox(const TInstant *inst, void *bbox); +extern void tinstarr_set_bbox(TInstant **instants, int count, + bool lower_inc, bool upper_inc, interpType interp, void *bbox); +extern void tsequence_compute_bbox(TSequence *seq); +extern void tseqarr_compute_bbox(TSequence **sequences, int count, void *bbox); +extern void tsequenceset_compute_bbox(TSequenceSet *ss); + +/* Bounding box operators for temporal types */ + +extern bool boxop_temporal_tstzspan(const Temporal *temp, const Span *s, + bool (*func)(const Span *, const Span *), bool invert); +extern bool boxop_temporal_temporal(const Temporal *temp1, + const Temporal *temp2, bool (*func)(const Span *, const Span *)); + +extern bool boxop_tnumber_numspan(const Temporal *temp, const Span *span, + bool (*func)(const Span *, const Span *), bool invert); +extern bool boxop_tnumber_tbox(const Temporal *temp, const TBox *box, + bool (*func)(const TBox *, const TBox *), bool invert); +extern bool boxop_tnumber_tnumber(const Temporal *temp1, const Temporal *temp2, + bool (*func)(const TBox *, const TBox *)); + +/*****************************************************************************/ + +#endif /* __TEMPORAL_BOXOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_compops.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_compops.h new file mode 100644 index 0000000..02a975a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_compops.h @@ -0,0 +1,64 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever comparison operators (?=, ?<>, ?<, ?>, ?<=, ?>=), + * always comparison operators (%=, %<>, %<, %>, %<=, %>=), and + * temporal comparison operators (#=, #<>, #<, #>, #<=, #>=). + */ + +#ifndef __TEMPORAL_COMPOPS_H__ +#define __TEMPORAL_COMPOPS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +extern int eacomp_base_temporal(Datum value, const Temporal *temp, + Datum (*func)(Datum, Datum, MeosType), bool ever); +extern int eacomp_temporal_base(const Temporal *temp, Datum value, + Datum (*func)(Datum, Datum, MeosType), bool ever); +extern int eacomp_temporal_temporal(const Temporal *temp1, + const Temporal *temp2, Datum (*func)(Datum, Datum, MeosType), bool ever); + +extern Temporal *tcomp_base_temporal(Datum value, const Temporal *temp, + Datum (*func)(Datum, Datum, MeosType)); +extern Temporal *tcomp_temporal_base(const Temporal *temp, Datum value, + Datum (*func)(Datum, Datum, MeosType)); +extern Temporal *tcomp_temporal_temporal(const Temporal *temp1, + const Temporal *temp2, Datum (*func)(Datum, Datum, MeosType)); + +/*****************************************************************************/ + +#endif /* __TEMPORAL_COMPOPS_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_restrict.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_restrict.h new file mode 100644 index 0000000..559ea97 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_restrict.h @@ -0,0 +1,121 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Restriction functions for temporal value. + */ + +#ifndef __TEMPORAL_RESTRICT_H__ +#define __TEMPORAL_RESTRICT_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" +#include "temporal/temporal.h" + +/*****************************************************************************/ + +/* Restriction Functions */ + +extern TSequence *tcontseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tcontseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_after_timestamptz(const TSequence *seq, TimestampTz t, bool strict); +extern TSequence *tdiscseq_before_timestamptz(const TSequence *seq, TimestampTz t, bool strict); + +extern TInstant *tdiscseq_at_timestamptz(const TSequence *seq, TimestampTz t); +extern TSequence *tdiscseq_restrict_value(const TSequence *seq, Datum value, + bool atfunc); +extern TSequence *tdiscseq_restrict_values(const TSequence *seq, const Set *s, + bool atfunc); +extern TSequence *tdiscseq_restrict_minmax(const TSequence *seq, bool min, + bool atfunc); +extern TSequence *tdiscseq_minus_timestamptz(const TSequence *seq, + TimestampTz t); +extern TSequence *tdiscseq_restrict_tstzset(const TSequence *seq, + const Set *s, bool atfunc); +extern TSequence *tdiscseq_restrict_tstzspanset(const TSequence *seq, + const SpanSet *ss, bool atfunc); +extern int tcontseq_restrict_value_iter(const TSequence *seq, Datum value, + bool atfunc, TSequence **result); +extern TSequenceSet *tcontseq_restrict_minmax(const TSequence *seq, bool min, + bool atfunc); +extern TSequence *tcontseq_delete_timestamptz(const TSequence *seq, + TimestampTz t); +extern TSequence *tcontseq_delete_tstzset(const TSequence *seq, + const Set *s); +extern TSequence *tcontseq_delete_tstzspanset(const TSequence *seq, + const SpanSet *ss); +extern TSequence *tcontseq_at_tstzset(const TSequence *seq, const Set *s); +extern TSequenceSet *tcontseq_minus_timestamptz(const TSequence *seq, + TimestampTz t); +extern TSequenceSet *tcontseq_minus_tstzset(const TSequence *seq, + const Set *s); +extern TSequenceSet *tcontseq_minus_tstzspan(const TSequence *seq, + const Span *s); +extern TSequenceSet *tcontseq_restrict_value(const TSequence *seq, Datum value, + bool atfunc); +extern TSequenceSet *tcontseq_restrict_values(const TSequence *seq, + const Set *s, bool atfunc); +extern int tsequence_at_values_iter(const TSequence *seq, const Set *set, + TSequence **result); +extern int tnumberseq_cont_restrict_span_iter(const TSequence *seq, + const Span *span, bool atfunc, TSequence **result); +extern int tnumberseq_cont_restrict_spanset_iter(const TSequence *seq, + const SpanSet *ss, bool atfunc, TSequence **result); +extern TInstant *tsegment_at_timestamptz(const TInstant *inst1, + const TInstant *inst2, interpType interp, TimestampTz t); +extern int tcontseq_minus_timestamp_iter(const TSequence *seq, TimestampTz t, + TSequence **result); +extern int tcontseq_minus_tstzset_iter(const TSequence *seq, const Set *s, + TSequence **result); +extern int tcontseq_at_tstzspanset1(const TSequence *seq, const SpanSet *ss, + TSequence **result); +extern int tcontseq_minus_tstzspanset_iter(const TSequence *seq, const SpanSet *ss, + TSequence **result); +extern TSequence *tcontseq_at_tstzspan(const TSequence *seq, const Span *s); +extern TInstant *tcontseq_at_timestamptz(const TSequence *seq, TimestampTz t); +extern TSequenceSet *tcontseq_restrict_tstzspanset(const TSequence *seq, + const SpanSet *ss, bool atfunc); +extern bool tdiscseq_value_at_timestamptz(const TSequence *seq, TimestampTz t, + Datum *result); +extern TSequence *tnumberseq_disc_restrict_span(const TSequence *seq, + const Span *span, bool atfunc); +extern TSequence *tnumberseq_disc_restrict_spanset(const TSequence *seq, + const SpanSet *ss, bool atfunc); +extern TSequenceSet *tnumberseq_cont_restrict_span(const TSequence *seq, + const Span *span, bool atfunc); +extern TSequenceSet *tnumberseq_cont_restrict_spanset(const TSequence *seq, + const SpanSet *ss, bool atfunc); +extern double tnumberseq_cont_twavg(const TSequence *seq); + +/*****************************************************************************/ + +#endif /* __TEMPORAL_RESTRICT_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_rtree.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_rtree.h new file mode 100644 index 0000000..66d650e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_rtree.h @@ -0,0 +1,106 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief In memory index for STBox based on RTree + */ + +#ifndef __TEMPORAL_RTREE__ +#define __TEMPORAL_RTREE__ + +/* MEOS */ +#include + +#include "temporal/meos_catalog.h" + +/***************************************************************************** + * RTree + *****************************************************************************/ + +#define MAXITEMS 64 +#define MINITEMS_PERCENTAGE 10 +#define MINITEMS ((MAXITEMS) * (MINITEMS_PERCENTAGE) / 100 + 1) + +/** + * @brief Enumeration that defines the node types for an RTree. + */ +typedef enum +{ + RTREE_LEAF, + RTREE_INNER +} RTreeNodeType; + +/** + * @brief Internal representation of an RTree node. + */ +typedef struct RTreeNode +{ + size_t bboxsize; /**< Size of the bouding box */ + int count; /**< Number of bouding boxes */ + RTreeNodeType node_type; + union + { + struct RTreeNode *nodes[MAXITEMS]; + int ids[MAXITEMS]; + }; + /* The bounding boxes can be of type Span, TBox, or STBox */ + char boxes[]; +} RTreeNode; + +/** + * @brief Rtree in-memory index basic structure. + * @details It works based on Span, TBox and STBox. + * - The spliting criteria is based on the largest axis. + * - The inserting criteria is based on least enlarging square. + * - The get axis function makes it ease to implement with X,Y,Z and time or any + * combination that you may want. + */ +struct RTree +{ + size_t bboxsize; /**< Size of the bouding box */ + MeosType bboxtype; /**< Type of the bouding box */ + int dims; + RTreeNode *root; + double (*get_axis)(const void *, int, bool); + void (*bbox_expand)(const void *, void *); + bool (*bbox_contains)(const void *, const void *); + bool (*bbox_overlaps)(const void *, const void *); + char box[]; +}; + +/** + * @brief Return a pointer to the n-th bounding box of a node + * @details The bouding boxes of a node can be of type Span, TBox, or STBox + */ +#define RTREE_NODE_BBOX_N(node, n) ( (void *)( \ + ((char *) &((node)->boxes)) + (n) * (node)->bboxsize ) ) + +/*****************************************************************************/ + +#endif /* __TEMPORAL_RTREE__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_tile.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_tile.h new file mode 100644 index 0000000..276cec4 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_tile.h @@ -0,0 +1,110 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +#ifndef __TEMPORAL_TILE_H__ +#define __TEMPORAL_TILE_H__ + +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +#define MAXDIMS 4 + +/*****************************************************************************/ + +/** + * Struct for storing the state that persists across multiple calls generating + * the bin list + */ +typedef struct SpanBinState +{ + bool done; /**< True when the state is consumed */ + uint8 basetype; /**< span basetype */ + int i; /**< Current tile number */ + Datum size; /**< Size of the values */ + Datum origin; /**< Origin of the values */ + Span span; /**< Bounding span */ + const void *to_split; /**< NULL when generating bins, used for splitting + * span sets or temporal values*/ + Datum value; /**< Current value */ + int nbins; /**< Total number of bins */ +} SpanBinState; + +/** + * @brief Struct for storing the state for tiling operations + */ +typedef struct TboxGridState +{ + bool done; /**< True when the state is consumed */ + int i; /**< Current tile number */ + Datum vsize; /**< Value size */ + int64 tunits; /**< Time size */ + TBox box; /**< Bounding box */ + const Temporal *temp; /**< Optional temporal number to be split */ + Datum value; /**< Current value */ + TimestampTz t; /**< Current time */ + int ntiles; /**< Total number of tiles */ + int max_coords[2]; /**< Maximum coordinates of the tiles */ + int coords[2]; /**< Coordinates of the current tile */ +} TboxGridState; + +/*****************************************************************************/ + +extern int span_num_bins(const Span *s, Datum size, Datum origin, + Datum *start_bin, Datum *end_bin); + +extern Span *span_bins(const Span *s, Datum size, Datum origin, int *count); +extern Span *spanset_bins(const SpanSet *ss, Datum size, Datum origin, int *count); + +extern SpanBinState *temporal_time_bin_init(const Temporal *temp, + const Interval *duration, TimestampTz torigin, int *nbins); + +extern TboxGridState *tbox_tile_state_make(const Temporal *temp, + const TBox *box, Datum vsize, const Interval *duration, Datum xorigin, + TimestampTz torigin); +extern void tbox_tile_state_next(TboxGridState *state); +extern void tbox_tile_state_set(Datum value, TimestampTz t, Datum vsize, + int64 tunits, MeosType basetype, MeosType spantype, TBox *box); + +/*****************************************************************************/ + +extern int64 interval_units(const Interval *interval); +extern TimestampTz timestamptz_bin_start(TimestampTz timestamp, int64 tunits, + TimestampTz torigin); +extern Datum datum_bin(Datum value, Datum size, Datum offset, + MeosType basetype); + +extern TboxGridState *tnumber_value_time_tile_init(const Temporal *temp, + Datum vsize, const Interval *duration, Datum vorigin, TimestampTz torigin, + int *ntiles); +extern bool tbox_tile_state_get(TboxGridState *state, TBox *box); + +/*****************************************************************************/ +#endif /* __TEMPORAL_TILE_H__ */ + diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_waggfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_waggfuncs.h new file mode 100644 index 0000000..ed14489 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/temporal_waggfuncs.h @@ -0,0 +1,57 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal aggregate functions + */ + +#ifndef __TEMPORAL_WAGGFUNCS_H__ +#define __TEMPORAL_WAGGFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern TSequence **temporal_transform_wcount(const Temporal *temp, + const Interval *interval, int *count); +extern TSequence **tnumber_transform_wavg(const Temporal *temp, + const Interval *interval, int *count); +extern SkipList *temporal_wagg_transfn(SkipList *state, const Temporal *temp, + const Interval *interval, datum_func2 func, bool min, bool crossings); +extern SkipList *temporal_wagg_transform_transfn(SkipList *state, + const Temporal *temp, const Interval *interval, datum_func2 func, + TSequence ** (*transform)(const Temporal *, const Interval *, int *)); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tinstant.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tinstant.h new file mode 100644 index 0000000..6a28897 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tinstant.h @@ -0,0 +1,75 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for temporal instants. + */ + +#ifndef __TINSTANT_H__ +#define __TINSTANT_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +/* General functions */ + +extern void tinstant_set(TInstant *inst, Datum value, TimestampTz t); +extern double tnumberinst_double(const TInstant *inst); + +/* Input/output functions */ + +extern char *tinstant_to_string(const TInstant *inst, int maxdd, + outfunc value_out); + +/* Restriction Functions */ + +extern bool tinstant_restrict_values_test(const TInstant *inst, + const Set *s, bool atfunc); +extern bool tnumberinst_restrict_span_test(const TInstant *inst, + const Span *s, bool atfunc); +extern bool tnumberinst_restrict_spanset_test(const TInstant *inst, + const SpanSet *ss, bool atfunc); +extern bool tinstant_restrict_tstzset_test(const TInstant *inst, + const Set *s, bool atfunc); +extern bool tinstant_restrict_tstzspanset_test(const TInstant *inst, + const SpanSet *ss, bool atfunc); + +/* Intersection function */ + +extern bool intersection_tinstant_tinstant(const TInstant *inst1, + const TInstant *inst2, TInstant **inter1, TInstant **inter2); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tnumber_mathfuncs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tnumber_mathfuncs.h new file mode 100644 index 0000000..fb272ca --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tnumber_mathfuncs.h @@ -0,0 +1,72 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Mathematical operators (+, -, *, /) and functions (round, degrees, ...) + * for temporal numbers. + */ + +#ifndef __TEMPORAL_MATHFUNCS_H__ +#define __TEMPORAL_MATHFUNCS_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/** Enumeration for the arithmetic functions */ + +typedef enum +{ + ADD, + SUB, + MUL, + DIV, + DIST, +} TArithmetic; + +/*****************************************************************************/ + +extern int tfloat_arithop_turnpt(Datum start1, Datum end1, Datum start2, + Datum end2, Datum param UNUSED, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); + +extern Temporal *arithop_tnumber_number(const Temporal *temp, Datum value, + TArithmetic oper, Datum (*func)(Datum, Datum, MeosType), bool invert); +extern Temporal *arithop_tnumber_tnumber(const Temporal *temp1, + const Temporal *temp2, TArithmetic oper, + Datum (*func)(Datum, Datum, MeosType), tpfunc_temp tpfunc); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequence.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequence.h new file mode 100644 index 0000000..e5a0942 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequence.h @@ -0,0 +1,152 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for temporal sequences + */ + +#ifndef __TSEQUENCE_H__ +#define __TSEQUENCE_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/meos_catalog.h" +#include "temporal/temporal.h" + +/*****************************************************************************/ + +/* Collinear function */ + +extern bool float_collinear(double x1, double x2, double x3, double ratio); + +/* Interpolation functions */ + +extern double floatsegm_interpolate(double value1, double value2, + long double value); +extern long double floatsegm_locate(double value1, double value2, + double value); + +extern int tnumbersegm_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, MeosType basetype, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); + +/* Normalization functions */ + +extern bool tsequence_norm_test(Datum value1, Datum value2, Datum value3, + MeosType basetype, interpType interp, TimestampTz t1, TimestampTz t2, + TimestampTz t3); +extern bool tsequence_join_test(const TSequence *seq1, const TSequence *seq2, + bool *removelast, bool *removefirst); +extern TSequence *tsequence_join(const TSequence *seq1, const TSequence *seq2, + bool removelast, bool removefirst); +extern TInstant **tinstarr_normalize(TInstant **instants, interpType interp, + int count, int *newcount); + +/* General functions */ + +extern int tcontseq_find_timestamptz(const TSequence *seq, TimestampTz t); +extern int tdiscseq_find_timestamptz(const TSequence *seq, TimestampTz t); +extern TSequence **tseqarr2_to_tseqarr(TSequence ***sequences, int *countseqs, + int count, int totalseqs); + +extern bool ensure_valid_tinstarr_common(TInstant **instants, int count, + bool lower_inc, bool upper_inc, interpType interp); +extern TSequence *tsequence_make_exp1(TInstant **instants, int count, + int maxcount, bool lower_inc, bool upper_inc, interpType interp, + bool normalize, void *bbox); + +/* Synchronization functions */ + +extern bool synchronize_tsequence_tsequence(const TSequence *seq1, + const TSequence *seq2, TSequence **sync1, TSequence **sync2, + bool interpoint); + +/* Intersection functions */ + +extern int tfloatsegm_intersection_value(Datum start, Datum end, Datum value, + TimestampTz lower, TimestampTz upper, TimestampTz *t); +extern int tsegment_intersection_value(Datum start, Datum end, Datum value, + MeosType temptype, TimestampTz lower, TimestampTz upper, TimestampTz *t1, + TimestampTz *t2); +extern int tsegment_intersection(Datum start1, Datum end1, Datum start2, + Datum end2, MeosType temptype, TimestampTz lower, TimestampTz upper, + TimestampTz *t1, TimestampTz *t2); +extern Datum tsegment_value_at_timestamptz(Datum start, Datum end, + MeosType temptype, TimestampTz lower, TimestampTz upper, TimestampTz t); + +extern bool intersection_tdiscseq_tdiscseq(const TSequence *seq1, + const TSequence *seq2, TSequence **inter1, TSequence **inter2); +extern bool intersection_tcontseq_tdiscseq(const TSequence *seq1, + const TSequence *seq2, TSequence **inter1, TSequence **inter2); +extern bool intersection_tdiscseq_tcontseq(const TSequence *is, + const TSequence *seq2, TSequence **inter1, TSequence **inter2); + +extern bool intersection_tsequence_tinstant(const TSequence *seq, + const TInstant *inst, TInstant **inter1, TInstant **inter2); +extern bool intersection_tinstant_tsequence(const TInstant *inst, + const TSequence *seq, TInstant **inter1, TInstant **inter2); + +/* Input/output functions */ + +extern char *tsequence_to_string(const TSequence *seq, int maxdd, + bool component, outfunc value_out); + +/* Constructor functions */ + +extern bool ensure_increasing_timestamps(const TInstant *inst1, + const TInstant *inst2, bool strict); +extern void bbox_expand(const void *box1, void *box2, MeosType temptype); +extern bool ensure_valid_tinstarr(TInstant **instants, int count, bool merge, + interpType interp); +extern bool tsequence_make_valid(TInstant **instants, int count, + bool lower_inc, bool upper_inc, interpType interp); + +/* Transformation functions */ + +extern void tnumberseq_shift_scale_value_iter(TSequence *seq, Datum origin, + Datum delta, bool hasdelta, double scale); +extern void tsequence_shift_scale_time_iter(TSequence *seq, TimestampTz delta, + double scale); +extern int tstepseq_to_linear_iter(const TSequence *seq, TSequence **result); +extern TSequenceSet *tstepseq_to_linear(const TSequence *seq); + +/* Accessor functions */ + +extern int tsequence_segments_iter(const TSequence *seq, TSequence **result); +extern int tsequence_timestamps_iter(const TSequence *seq, TimestampTz *result); + +/* Local Aggregate Functions */ + +extern double tnumberseq_cont_twavg(const TSequence *seq); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequenceset.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequenceset.h new file mode 100644 index 0000000..30218e9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/tsequenceset.h @@ -0,0 +1,87 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic functions for temporal sequence sets. + */ + +#ifndef __TSEQUENCESET_H__ +#define __TSEQUENCESET_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +/* General functions */ + +extern bool tsequenceset_find_timestamptz(const TSequenceSet *ss, + TimestampTz t, int *loc); +extern TSequence **tseqarr_normalize(TSequence **sequences, int count, + int *newcount); +extern double datum_distance(Datum value1, Datum value2, MeosType basetype, + int16 flags); +extern int *ensure_valid_tinstarr_gaps(TInstant **instants, int count, + bool merge, double maxdist, const Interval *maxt, int *nsplits); +extern bool ensure_valid_tseqarr(TSequence **sequences, int count); + +/* Synchronize functions */ + +extern bool synchronize_tsequenceset_tsequence(const TSequenceSet *ss, + const TSequence *seq, SyncMode mode, + TSequenceSet **inter1, TSequenceSet **inter2); +extern bool synchronize_tsequenceset_tsequenceset(const TSequenceSet *ss1, + const TSequenceSet *ss2, SyncMode mode, + TSequenceSet **inter1, TSequenceSet **inter2); + +/* Intersection functions */ + +extern bool intersection_tsequenceset_tinstant(const TSequenceSet *ss, + const TInstant *inst, TInstant **inter1, TInstant **inter2); +extern bool intersection_tinstant_tsequenceset(const TInstant *inst, + const TSequenceSet *ss, TInstant **inter1, TInstant **inter2); +extern bool intersection_tsequenceset_tdiscseq(const TSequenceSet *ss, + const TSequence *is, TSequence **inter1, TSequence **inter2); +extern bool intersection_tdiscseq_tsequenceset(const TSequence *is, + const TSequenceSet *ss, TSequence **inter1, TSequence **inter2); +extern bool intersection_tsequence_tsequenceset(const TSequence *seq, + const TSequenceSet *ss, SyncMode mode, + TSequenceSet **inter1, TSequenceSet **inter2); + +/* Input/output functions */ + +extern char *tsequenceset_to_string(const TSequenceSet *ss, int maxdd, + outfunc value_out); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/ttext_funcs.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/ttext_funcs.h new file mode 100644 index 0000000..ff14f39 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/ttext_funcs.h @@ -0,0 +1,59 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Temporal text functions: `textcat`, `lower`, `upper`. + */ + +#ifndef __TTEXT_TEXTFUNCS_H__ +#define __TTEXT_TEXTFUNCS_H__ + +/* PostgreSQL */ +#include +/* PostgreSQL */ +#include +#include "temporal/temporal.h" + +/*****************************************************************************/ + +extern Datum datum_textcat(Datum l, Datum r); +extern Datum datum_lower(Datum value); +extern Datum datum_upper(Datum value); +extern Datum datum_initcap(Datum value); + +extern Temporal *textfunc_ttext(const Temporal *temp, + datum_func1 func); +extern Temporal *textfunc_ttext_text(const Temporal *temp, Datum value, + datum_func2 func, bool invert); +extern Temporal *textfunc_ttext_ttext(const Temporal *temp1, + const Temporal *temp2, datum_func2 func); + +/*****************************************************************************/ + +#endif diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_inout.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_inout.h new file mode 100644 index 0000000..fead624 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_inout.h @@ -0,0 +1,75 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Basic routines for spans (a.k.a. ranges) composed of two `Datum` + * values and two Boolean values stating whether the bounds are inclusive. + */ + +#ifndef __TYPE_INOUT_H__ +#define __TYPE_INOUT_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include "temporal/meos_catalog.h" + +/***************************************************************************** + * Definitions taken from the file liblwgeom_internal.h + *****************************************************************************/ + +/* Any (absolute) values outside this range will be printed in scientific + * notation */ +#define OUT_MIN_DOUBLE 1E-8 +#define OUT_MAX_DOUBLE 1E15 +#define OUT_DEFAULT_DECIMAL_DIGITS 15 + +/* 17 digits are sufficient for round-tripping + * Then we might add up to 8 (from OUT_MIN_DOUBLE) max leading zeroes (or + * 2 digits for "e+") */ +#define OUT_MAX_DIGITS 17 + 8 + +/* Limit for the max amount of characters that a double can use, including dot + * and sign */ +#define OUT_MAX_BYTES_DOUBLE (1 /* Sign */ + 2 /* 0.x */ + OUT_MAX_DIGITS) +#define OUT_DOUBLE_BUFFER_SIZE OUT_MAX_BYTES_DOUBLE + 1 /* +1 including NULL */ + +/*****************************************************************************/ + +extern uint8_t *datum_as_wkb(Datum value, MeosType type, uint8_t variant, + size_t *size_out); +extern char *datum_as_hexwkb(Datum value, MeosType type, uint8_t variant, + size_t *size); + +extern Datum type_from_wkb(const uint8_t *wkb, size_t size, MeosType type); +extern Datum type_from_hexwkb(const char *hexwkb, size_t size, MeosType type); + +/*****************************************************************************/ + +#endif /* __TYPE_INOUT_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_parser.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_parser.h new file mode 100644 index 0000000..60f79eb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_parser.h @@ -0,0 +1,77 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Functions for parsing temporal types. + */ + +#ifndef __TYPE_PARSER_H__ +#define __TYPE_PARSER_H__ + +/* MEOS */ +#include +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +extern bool ensure_end_input(const char **str, const char *type); +extern void p_whitespace(const char **str); +extern bool p_delimchar(const char **str, char delim); +extern bool p_obrace(const char **str); +extern bool ensure_obrace(const char **str, const char *type); +extern bool p_cbrace(const char **str); +extern bool ensure_cbrace(const char **str, const char *type); +extern bool p_obracket(const char **str); +extern bool p_cbracket(const char **str); +extern bool p_oparen(const char **str); +extern bool ensure_oparen(const char **str, const char *type); +extern bool p_cparen(const char **str); +extern bool ensure_cparen(const char **str, const char *type); +extern bool p_comma(const char **str); +extern bool basetype_parse(const char **str, MeosType basetypid, char delim, + Datum *result); +extern bool double_parse(const char **str, double *result); +extern bool elem_parse(const char **str, MeosType basetype, Datum *result); +extern Set *set_parse(const char **str, MeosType basetype); +extern bool span_parse(const char **str, MeosType spantype, bool end, + Span *span); +extern SpanSet *spanset_parse(const char **str, MeosType spantype); +extern TBox *tbox_parse(const char **str); +extern TimestampTz timestamp_parse(const char **str); +extern TInstant *tinstant_parse(const char **str, MeosType temptype, bool end); +extern TSequence *tdiscseq_parse(const char **str, MeosType temptype); +extern TSequence *tcontseq_parse(const char **str, MeosType temptype, + interpType interp, bool end); +extern TSequenceSet *tsequenceset_parse(const char **str, MeosType temptype, + interpType interp); +extern Temporal *temporal_parse(const char **str, MeosType temptype); + +/*****************************************************************************/ + +#endif /* __TYPE_PARSER_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_util.h b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_util.h new file mode 100644 index 0000000..0aaeb18 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/meos/include/temporal/type_util.h @@ -0,0 +1,120 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @brief Miscellaneous utility functions for temporal types. + */ + +#ifndef __TYPE_UTIL_H__ +#define __TYPE_UTIL_H__ + +/* PostgreSQL */ +#include +/* MEOS */ +#include +#include +#include +#include "temporal/doublen.h" +#include "temporal/meos_catalog.h" + +/*****************************************************************************/ + +/** Symbolic constants for the *_to_arr() functions */ +#define FREE_ALL true +#define FREE false + +/*****************************************************************************/ + +/* Miscellaneous functions */ + +extern Datum datum_copy(Datum value, MeosType typid); +extern double datum_double(Datum d, MeosType type); +extern Datum double_datum(double d, MeosType type); +extern bytea *bstring2bytea(const uint8_t *wkb, size_t size); + +/* Input/output functions */ + +extern bool basetype_in(const char *str, MeosType type, bool end, Datum *result); +extern char *basetype_out(Datum value, MeosType type, int maxdd); + +/* Array functions */ + +extern void pfree_array(void **array, int count); +extern char *stringarr_to_string(char **strings, int count, size_t outlen, + char *prefix, char open, char close, bool quotes, bool spaces); + +/* Sort functions */ + +extern void datumarr_sort(Datum *values, int count, MeosType basetype); +extern void tstzarr_sort(TimestampTz *times, int count); +extern void spanarr_sort(Span *spans, int count); +extern void tinstarr_sort(TInstant **instants, int count); +extern void tseqarr_sort(TSequence **sequences, int count); + +/* Remove duplicate functions */ + +extern int datumarr_remove_duplicates(Datum *values, int count, + MeosType basetype); +extern int tstzarr_remove_duplicates(TimestampTz *values, int count); +extern int tinstarr_remove_duplicates(TInstant **instants, int count); + +/* Text functions */ + + +/* Arithmetic functions */ + +extern Datum datum_add(Datum l, Datum r, MeosType type); +extern Datum datum_sub(Datum l, Datum r, MeosType type); +extern Datum datum_mul(Datum l, Datum r, MeosType type); +extern Datum datum_div(Datum l, Datum r, MeosType type); + +/* Comparison functions on datums */ + +extern int datum_cmp(Datum l, Datum r, MeosType type); +extern bool datum_eq(Datum l, Datum r, MeosType type); +extern bool datum_ne(Datum l, Datum r, MeosType type); +extern bool datum_lt(Datum l, Datum r, MeosType type); +extern bool datum_le(Datum l, Datum r, MeosType type); +extern bool datum_gt(Datum l, Datum r, MeosType type); +extern bool datum_ge(Datum l, Datum r, MeosType type); + +extern Datum datum2_eq(Datum l, Datum r, MeosType type); +extern Datum datum2_ne(Datum l, Datum r, MeosType type); +extern Datum datum2_lt(Datum l, Datum r, MeosType type); +extern Datum datum2_le(Datum l, Datum r, MeosType type); +extern Datum datum2_gt(Datum l, Datum r, MeosType type); +extern Datum datum2_ge(Datum l, Datum r, MeosType type); + +/* Hypothenuse functions */ + +extern double hypot3d(double x, double y, double z); + +/*****************************************************************************/ + +#endif /* __TYPE_UTIL_H__ */ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/CMakeLists.txt new file mode 100644 index 0000000..3613ede --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/CMakeLists.txt @@ -0,0 +1,101 @@ +set(MOBILITYDB_MODULE_PATHNAME "$libdir/lib${MOBILITYDB_LIB_NAME}") +set(extschema "@extschema@") + +configure_file(mobilitydb.in.control ${CMAKE_BINARY_DIR}/mobilitydb.control) + +macro(process_file f srcdir bindir) + file(READ ${srcdir}/${f}.in.sql CURR_CONTENTS) + + if (${POSTGRESQL_VERSION_NUMBER} GREATER_EQUAL 130000) + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 130000" "-- if POSTGRESQL_VERSION_NUMBER >= 130000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 130000" "-- endif POSTGRESQL_VERSION_NUMBER >= 130000" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 130000" "/* --if POSTGRESQL_VERSION_NUMBER < 130000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 130000" "-- endif POSTGRESQL_VERSION_NUMBER < 130000 */" CURR_CONTENTS "${CURR_CONTENTS}") + else() + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 130000" "/* -- if POSTGRESQL_VERSION_NUMBER >= 130000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 130000" "-- endif POSTGRESQL_VERSION_NUMBER >= 130000 */" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 130000" " -- if POSTGRESQL_VERSION_NUMBER >= 130000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 130000" "-- endif POSTGRESQL_VERSION_NUMBER >= 130000" CURR_CONTENTS "${CURR_CONTENTS}") + endif() + + if (${POSTGRESQL_VERSION_NUMBER} GREATER_EQUAL 140000) + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 140000" "-- if POSTGRESQL_VERSION_NUMBER >= 140000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 140000" "-- endif POSTGRESQL_VERSION_NUMBER >= 140000" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 140000" "/* --if POSTGRESQL_VERSION_NUMBER < 140000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 140000" "-- endif POSTGRESQL_VERSION_NUMBER < 140000 */" CURR_CONTENTS "${CURR_CONTENTS}") + else() + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 140000" "/* -- if POSTGRESQL_VERSION_NUMBER >= 140000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 140000" "-- endif POSTGRESQL_VERSION_NUMBER >= 140000 */" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 140000" " -- if POSTGRESQL_VERSION_NUMBER >= 140000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 140000" "-- endif POSTGRESQL_VERSION_NUMBER >= 140000" CURR_CONTENTS "${CURR_CONTENTS}") + endif() + + if (${POSTGRESQL_VERSION_NUMBER} GREATER_EQUAL 160000) + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 160000" "-- if POSTGRESQL_VERSION_NUMBER >= 160000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 160000" "-- endif POSTGRESQL_VERSION_NUMBER >= 160000" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 160000" "/* --if POSTGRESQL_VERSION_NUMBER < 160000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 160000" "-- endif POSTGRESQL_VERSION_NUMBER < 160000 */" CURR_CONTENTS "${CURR_CONTENTS}") + else() + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER >= 160000" "/* -- if POSTGRESQL_VERSION_NUMBER >= 160000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER >= 160000" "-- endif POSTGRESQL_VERSION_NUMBER >= 160000 */" CURR_CONTENTS "${CURR_CONTENTS}") + + string(REPLACE "#if POSTGRESQL_VERSION_NUMBER < 160000" " -- if POSTGRESQL_VERSION_NUMBER >= 160000" CURR_CONTENTS "${CURR_CONTENTS}") + string(REPLACE "#endif //POSTGRESQL_VERSION_NUMBER < 160000" "-- endif POSTGRESQL_VERSION_NUMBER >= 160000" CURR_CONTENTS "${CURR_CONTENTS}") + endif() + + file(WRITE ${bindir}/${f}.sql.in "${CURR_CONTENTS}") +endmacro() + +add_subdirectory(temporal) +add_subdirectory(geo) +if(CBUFFER) + add_subdirectory(cbuffer) +endif() +if(NPOINT) + add_subdirectory(npoint) +endif() +if(POSE) + add_subdirectory(pose) +endif() +if(RGEO) + add_subdirectory(rgeo) +endif() + +list(SORT PROJECT_SQL_FILES) + +add_custom_target(all_sql_files ALL + DEPENDS ${PROJECT_SQL_FILES}) + +if (PROJECT_VERBOSE) + message(STATUS "PROJECT_SQL_FILES=${PROJECT_SQL_FILES}") +endif() + +# Truncate first: without this, re-running cmake on an existing build +# directory keeps appending to the previous pass's file, duplicating every +# CREATE FUNCTION / TYPE / OPERATOR and making `CREATE EXTENSION mobilitydb` +# fail with 'already exists' errors on subsequent reconfigures. +file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${MOBILITYDB_EXTENSION_FILE}.in "") +foreach (f ${PROJECT_SQL_FILES}) + file(READ ${f} CURR_CONTENTS) + file(APPEND ${CMAKE_CURRENT_BINARY_DIR}/${MOBILITYDB_EXTENSION_FILE}.in "${CURR_CONTENTS}") +endforeach() + +configure_file(${CMAKE_CURRENT_BINARY_DIR}/${MOBILITYDB_EXTENSION_FILE}.in ${CMAKE_BINARY_DIR}/${MOBILITYDB_EXTENSION_FILE} COPYONLY) + +# Set the library name extension according to the platform +if(WIN32) + set(LIB_NAME_EXT ".dll") +else() + set(LIB_NAME_EXT ".so") +endif() +message(STATUS "Library name extension: '${LIB_NAME_EXT}'") + +file(READ "${CMAKE_BINARY_DIR}/${MOBILITYDB_EXTENSION_FILE}" sql_commands) +string(REPLACE "MODULE_PATHNAME" "${CMAKE_BINARY_DIR}/lib${MOBILITYDB_LIB_NAME}${LIB_NAME_EXT}" sql_commands "${sql_commands}") +message(STATUS "Substitution: ${CMAKE_BINARY_DIR}/lib${MOBILITYDB_LIB_NAME}${LIB_NAME_EXT}") +string(REPLACE "@extschema@" "public" sql_commands "${sql_commands}") diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/150_cbuffer.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/150_cbuffer.in.sql new file mode 100644 index 0000000..4593381 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/150_cbuffer.in.sql @@ -0,0 +1,313 @@ + + +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file cbuffer.sql + * @brief Static circular buffer type + */ + +CREATE TYPE cbuffer; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION cbuffer_in(cstring) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_in' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION cbuffer_out(cbuffer) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Cbuffer_out' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION cbuffer_recv(internal) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_recv' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION cbuffer_send(cbuffer) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Cbuffer_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE cbuffer ( + internallength = variable, + input = cbuffer_in, + output = cbuffer_out, + receive = cbuffer_recv, + send = cbuffer_send, + storage = plain, + alignment = double +); + +-- Input/output in WKT, WKB and HexWKB representation + +CREATE FUNCTION asText(cbuffer, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Cbuffer_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(cbuffer[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(cbuffer, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Cbuffer_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(cbuffer[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION cbuffer(geometry, double precision) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +CREATE FUNCTION geometry(cbuffer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Cbuffer_to_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer(geometry) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Geom_to_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (cbuffer AS geometry) WITH FUNCTION geometry(cbuffer); +CREATE CAST (geometry AS cbuffer) WITH FUNCTION cbuffer(geometry); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +CREATE FUNCTION point(cbuffer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Cbuffer_point' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION radius(cbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'Cbuffer_radius' + LANGUAGE C IMMUTABLE STRICT; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION round(cbuffer, integer DEFAULT 0) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * SRID functions + *****************************************************************************/ + +CREATE FUNCTION SRID(cbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Cbuffer_srid' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION setSRID(cbuffer, integer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(cbuffer, integer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(cbuffer, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Cbuffer_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Spatial relationships + *****************************************************************************/ + +CREATE FUNCTION cbuffer_contains(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_contains' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer_covers(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_covers' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer_disjoint(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_disjoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer_intersects(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_intersects' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer_touches(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_touches' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffer_dwithin(cbuffer, cbuffer, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_dwithin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION cbuffer_same(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = cbuffer_same, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/****************************************************************************** + * Comparisons + ******************************************************************************/ + +CREATE FUNCTION cbuffer_eq(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_ne(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_lt(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_le(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_ge(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_gt(cbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Cbuffer_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_cmp(cbuffer, cbuffer) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Cbuffer_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + PROCEDURE = cbuffer_eq, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = cbuffer_ne, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = cbuffer_lt, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = cbuffer_le, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = cbuffer_ge, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargesel, JOIN = scalargejoinsel +); +CREATE OPERATOR > ( + PROCEDURE = cbuffer_gt, + LEFTARG = cbuffer, RIGHTARG = cbuffer, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS cbuffer_btree_ops + DEFAULT FOR TYPE cbuffer USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 cbuffer_cmp(cbuffer, cbuffer); + +/******************************************************************************/ + +CREATE FUNCTION cbuffer_hash(cbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Cbuffer_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbuffer_hash_extended(cbuffer, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Cbuffer_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS cbuffer_hash_ops + DEFAULT FOR TYPE cbuffer USING hash AS + OPERATOR 1 = , + FUNCTION 1 cbuffer_hash(cbuffer), + FUNCTION 2 cbuffer_hash_extended(cbuffer, bigint); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/151_cbufferset.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/151_cbufferset.in.sql new file mode 100644 index 0000000..a5cd44b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/151_cbufferset.in.sql @@ -0,0 +1,514 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for set of poses + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE cbufferset; + +CREATE FUNCTION cbufferset_in(cstring) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbufferset_out(cbufferset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbufferset_recv(internal) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cbufferset_send(cbufferset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE cbufferset ( + internallength = variable, + input = cbufferset_in, + output = cbufferset_out, + receive = cbufferset_recv, + send = cbufferset_send, + alignment = double, + storage = extended + -- , analyze = geoset_analyze +); + +/******************************************************************************/ + +-- Input/output in WKB and HexWKB representation + +CREATE FUNCTION cbuffersetFromBinary(bytea) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cbuffersetFromHexWKB(text) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(cbufferset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(cbufferset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(cbufferset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(cbufferset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION set(cbuffer[]) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION set(cbuffer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (cbuffer AS cbufferset) WITH FUNCTION set(cbuffer); + +CREATE FUNCTION stbox(cbufferset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Spatialset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (cbufferset AS stbox) WITH FUNCTION stbox(cbufferset); + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION round(cbufferset, integer DEFAULT 0) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION memSize(cbufferset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numValues(cbufferset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(cbufferset) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(cbufferset) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(cbufferset, integer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getValues(cbufferset) + RETURNS cbuffer[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * SRID + ******************************************************************************/ + +CREATE FUNCTION SRID(cbufferset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spatialset_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(cbufferset, integer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Spatialset_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(cbufferset, integer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Spatialset_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(cbufferset, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Spatialset_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation set of values <-> set + ******************************************************************************/ + +CREATE FUNCTION unnest(cbufferset) + RETURNS SETOF cbuffer + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, cbuffer) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, cbufferset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION cbufferset_union_finalfn(internal) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE setUnion(cbuffer) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = cbufferset_union_finalfn +); +CREATE AGGREGATE setUnion(cbufferset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = cbufferset_union_finalfn +); + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION set_eq(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(cbufferset, cbufferset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(cbufferset, cbufferset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >= + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = > + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = < + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = cbufferset, RIGHTARG = cbufferset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <= + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS cbufferset_btree_ops + DEFAULT FOR TYPE cbufferset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(cbufferset, cbufferset); + +/******************************************************************************/ + +CREATE FUNCTION set_hash(cbufferset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(cbufferset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS cbufferset_hash_ops + DEFAULT FOR TYPE cbufferset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(cbufferset), + FUNCTION 2 set_hash_extended(cbufferset, bigint); + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION set_contains(cbufferset, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(cbufferset, cbufferset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = cbufferset, RIGHTARG = cbuffer, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_contained(cbuffer, cbufferset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(cbufferset, cbufferset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = cbuffer, RIGHTARG = cbufferset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overlaps(cbufferset, cbufferset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = && + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION set_union(cbuffer, cbufferset) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(cbufferset, cbuffer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(cbufferset, cbufferset) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = cbuffer, RIGHTARG = cbufferset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = cbufferset, RIGHTARG = cbuffer, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION set_minus(cbuffer, cbufferset) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(cbufferset, cbuffer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(cbufferset, cbufferset) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = cbuffer, RIGHTARG = cbufferset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = cbufferset, RIGHTARG = cbuffer +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = cbufferset, RIGHTARG = cbufferset +); + +/*****************************************************************************/ + +CREATE FUNCTION set_intersection(cbuffer, cbufferset) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(cbufferset, cbuffer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(cbufferset, cbufferset) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = cbuffer, RIGHTARG = cbufferset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = cbufferset, RIGHTARG = cbuffer, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = * +); + +/*****************************************************************************/ + +CREATE FUNCTION set_distance(cbuffer, cbufferset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(cbufferset, cbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(cbufferset, cbufferset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = cbuffer, RIGHTARG = cbufferset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = cbufferset, RIGHTARG = cbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = cbufferset, RIGHTARG = cbufferset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/152_tcbuffer.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/152_tcbuffer.in.sql new file mode 100644 index 0000000..eb2bb75 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/152_tcbuffer.in.sql @@ -0,0 +1,715 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal circular buffers + */ + +CREATE TYPE tcbuffer; + +/***************************************************************************** + * Input/Output + *****************************************************************************/ + +CREATE FUNCTION tcbuffer_in(cstring, oid, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Temporal_out(tcbuffer) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tcbuffer_recv(internal, oid, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tcbuffer) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbuffer_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tcbuffer_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tcbuffer ( + internallength = variable, + input = tcbuffer_in, + output = temporal_out, + receive = tcbuffer_recv, + send = temporal_send, + typmod_in = tcbuffer_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tcbuffer(tcbuffer, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME','Tcbuffer_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tcbuffer AS tcbuffer) WITH FUNCTION tcbuffer(tcbuffer, integer) AS IMPLICIT; + +/***************************************************************************** + * Input/output from (E)WKT, (E)WKB, HexEWKB, and MFJSON representation + *****************************************************************************/ + +CREATE FUNCTION tcbufferFromText(text) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbufferFromEWKT(text) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbufferFromBinary(bytea) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbufferFromEWKB(bytea) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbufferFromHexEWKB(text) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asText(tcbuffer, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tcbuffer[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tcbuffer, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tcbuffer[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tcbuffer, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(tcbuffer, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(tcbuffer, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Constructors + *****************************************************************************/ + +CREATE FUNCTION tcbuffer(cbuffer, timestamptz) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbuffer(cbuffer, tstzset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbuffer(cbuffer, tstzspan, text DEFAULT 'linear') + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbuffer(cbuffer, tstzspanset, text DEFAULT 'linear') + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION tcbufferSeq(tcbuffer[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbufferSeqSet(tcbuffer[]) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tcbufferSeqSetGaps(tcbuffer[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION tcbuffer(tgeompoint, tfloat) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Conversions + *****************************************************************************/ + +CREATE FUNCTION timeSpan(tcbuffer) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeompoint(tcbuffer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tcbuffer_to_tgeompoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(tcbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tcbuffer_to_tfloat' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tcbuffer(tgeompoint) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tgeometry_to_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tcbuffer(tgeometry) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tgeometry_to_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tcbuffer AS tstzspan) WITH FUNCTION timeSpan(tcbuffer); +CREATE CAST (tcbuffer AS tgeompoint) WITH FUNCTION tgeompoint(tcbuffer); +CREATE CAST (tcbuffer AS tfloat) WITH FUNCTION tfloat(tcbuffer); +CREATE CAST (tgeompoint AS tcbuffer) WITH FUNCTION tcbuffer(tgeompoint); +CREATE CAST (tgeometry AS tcbuffer) WITH FUNCTION tcbuffer(tgeometry); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ +-- Specific accessors for temporal circular buffers + +CREATE FUNCTION points(tcbuffer) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Tcbuffer_points' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION radius(tcbuffer) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Tcbuffer_radius' + LANGUAGE C IMMUTABLE STRICT; + +/*****************************************************************************/ +-- Accessors for all temporal types + +CREATE FUNCTION tempSubtype(tcbuffer) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tcbuffer) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(tcbuffer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getTimestamp(tcbuffer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- values is a reserved word in SQL +CREATE FUNCTION getValues(tcbuffer) + RETURNS cbufferset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tcbuffer) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tcbuffer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tcbuffer) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tcbuffer, int) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tcbuffer, timestamptz) + RETURNS cbuffer + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tcbuffer, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tcbuffer, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tcbuffer) + RETURNS tcbuffer[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tcbuffer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tcbuffer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tcbuffer, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tcbuffer) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tcbuffer, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tcbuffer) + RETURNS tcbuffer[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tcbuffer) + RETURNS tcbuffer[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION expand(tcbuffer, float) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_expand' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ +-- Transformations for all temporal types + +CREATE FUNCTION tcbufferInst(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tcbufferSeq(tcbuffer, text DEFAULT NULL) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tcbufferSeqSet(tcbuffer, text DEFAULT NULL) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tcbuffer, text) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tcbuffer, integer DEFAULT 0) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tcbuffer[], integer DEFAULT 0) + RETURNS tcbuffer[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftTime(tcbuffer, interval) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tcbuffer, interval) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tcbuffer, interval, interval) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +CREATE FUNCTION atValues(tcbuffer, cbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tcbuffer, cbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tcbuffer, cbufferset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tcbuffer, cbufferset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tcbuffer, timestamptz) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tcbuffer, timestamptz) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tcbuffer, tstzset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tcbuffer, tstzset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tcbuffer, tstzspan) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tcbuffer, tstzspan) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tcbuffer, tstzspanset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tcbuffer, tstzspanset) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tcbuffer, timestamptz, strict bool DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tcbuffer, timestamptz, strict bool DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE TYPE cbuffer_tstzspanset AS ( + value cbuffer, + time tstzspanset +); + +CREATE FUNCTION unnest(tcbuffer) + RETURNS SETOF cbuffer_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stop Function + *****************************************************************************/ + +CREATE FUNCTION stops(tcbuffer, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tcbuffer, tcbuffer, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tcbuffer, tcbuffer, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tcbuffer, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tcbuffer, tstzset, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tcbuffer, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tcbuffer, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION merge(tcbuffer[]) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Multidimensional tiling + *****************************************************************************/ + +CREATE TYPE time_tcbuffer AS ( + time timestamptz, + temp tcbuffer +); + +CREATE FUNCTION timeSplit(tcbuffer, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Comparison functions and B-tree indexing + *****************************************************************************/ + +CREATE FUNCTION temporal_lt(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tcbuffer, tcbuffer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tcbuffer, tcbuffer) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS tcbuffer_btree_ops + DEFAULT FOR TYPE tcbuffer USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tcbuffer, tcbuffer); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_hash(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tcbuffer_hash_ops + DEFAULT FOR TYPE tcbuffer USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tcbuffer); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/154_tcbuffer_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/154_tcbuffer_compops.in.sql new file mode 100644 index 0000000..ae0365c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/154_tcbuffer_compops.in.sql @@ -0,0 +1,248 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever/always and temporal comparison functions and operators for + * temporal circular buffers + */ + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal equal + *****************************************************************************/ + +CREATE FUNCTION temporal_teq(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal not equal + *****************************************************************************/ + +CREATE FUNCTION temporal_tne(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = #<> +); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/155_tcbuffer_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/155_tcbuffer_spatialfuncs.in.sql new file mode 100644 index 0000000..fe69fa2 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/155_tcbuffer_spatialfuncs.in.sql @@ -0,0 +1,104 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial functions for temporal circular buffers + */ + +/***************************************************************************** + * SRID + *****************************************************************************/ + +CREATE FUNCTION SRID(tcbuffer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tcbuffer, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(tcbuffer, integer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(tcbuffer, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Traversed area + *****************************************************************************/ + +CREATE FUNCTION traversedArea(tcbuffer, bool DEFAULT true) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tcbuffer_traversed_area' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * AtGeometry and MinusGeometry + *****************************************************************************/ + +CREATE FUNCTION atValue(tcbuffer, cbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_at_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValue(tcbuffer, cbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_minus_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atGeometry(tcbuffer, geometry) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_at_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusGeometry(tcbuffer, geometry) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Tcbuffer_minus_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION atStbox(tcbuffer, stbox, bool DEFAULT TRUE) + -- RETURNS tcbuffer + -- AS 'MODULE_PATHNAME', 'Tcbuffer_at_stbox' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION minusStbox(tcbuffer, stbox, bool DEFAULT TRUE) + -- RETURNS tcbuffer + -- AS 'MODULE_PATHNAME', 'Tcbuffer_minus_stbox' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/158_tcbuffer_topops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/158_tcbuffer_topops.in.sql new file mode 100644 index 0000000..264dd90 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/158_tcbuffer_topops.in.sql @@ -0,0 +1,379 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal circular buffers + */ + +/***************************************************************************** + * Temporal cbuffer to stbox + *****************************************************************************/ + +CREATE FUNCTION stbox(cbuffer) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Cbuffer_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(cbuffer, timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Cbuffer_timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(cbuffer, tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Cbuffer_tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(tcbuffer) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (cbuffer AS stbox) WITH FUNCTION stbox(cbuffer); +CREATE CAST (tcbuffer AS stbox) WITH FUNCTION stbox(tcbuffer); + +/*****************************************************************************/ + +CREATE FUNCTION expandSpace(tcbuffer, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tcbuffer, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contains(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tcbuffer, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tcbuffer, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contained(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tcbuffer, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tcbuffer, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_overlaps(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tcbuffer, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tcbuffer, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_same(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tcbuffer, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tcbuffer, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_adjacent(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tcbuffer, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/159_tcbuffer_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/159_tcbuffer_posops.in.sql new file mode 100644 index 0000000..14a053b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/159_tcbuffer_posops.in.sql @@ -0,0 +1,487 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for temporal circular buffers + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tcbuffer */ + +CREATE FUNCTION temporal_before(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tcbuffer + *****************************************************************************/ + +/* tcbuffer op tstzspan */ + +CREATE FUNCTION temporal_before(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tcbuffer, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tcbuffer, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* tcbuffer op stbox */ + +CREATE FUNCTION temporal_left(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tcbuffer, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tcbuffer op tcbuffer */ + +CREATE FUNCTION temporal_left(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/160_tcbuffer_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/160_tcbuffer_distance.in.sql new file mode 100644 index 0000000..72f8a58 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/160_tcbuffer_distance.in.sql @@ -0,0 +1,279 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal circular buffers + */ + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION distance(geometry, cbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_geo_cbuffer' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION distance(stbox, cbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_stbox_cbuffer' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION distance(cbuffer, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_cbuffer_geo' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION distance(cbuffer, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_cbuffer_stbox' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION distance(cbuffer, cbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Distance_cbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = distance, + LEFTARG = geometry, + RIGHTARG = cbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = distance, + LEFTARG = stbox, + RIGHTARG = cbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = distance, + LEFTARG = cbuffer, + RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = distance, + LEFTARG = cbuffer, + RIGHTARG = stbox, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = distance, + LEFTARG = cbuffer, + RIGHTARG = cbuffer, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Temporal distance functions + *****************************************************************************/ + +CREATE FUNCTION tdistance(geometry(Point), tcbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(cbuffer, tcbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tcbuffer, geometry(Point)) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tcbuffer, cbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tcbuffer, tcbuffer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geometry, + RIGHTARG = tcbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = cbuffer, + RIGHTARG = tcbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tcbuffer, + RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tcbuffer, + RIGHTARG = cbuffer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tcbuffer, + RIGHTARG = tcbuffer, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant/distance and shortest line functions + *****************************************************************************/ + +CREATE FUNCTION nearestApproachInstant(geometry, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'NAI_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(stbox, tcbuffer) + RETURNS tcbuffer + AS 'SELECT @extschema@.nearestApproachInstant(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(cbuffer, tcbuffer) + RETURNS tcbuffer + AS 'SELECT @extschema@.nearestApproachInstant(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tcbuffer, geometry) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'NAI_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tcbuffer, stbox) + RETURNS tcbuffer + AS 'SELECT @extschema@.nearestApproachInstant($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tcbuffer, cbuffer) + RETURNS tcbuffer + AS 'SELECT @extschema@.nearestApproachInstant($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'NAI_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION nearestApproachDistance(geometry, tcbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tcbuffer) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(cbuffer, tcbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tcbuffer, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tcbuffer, stbox) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tcbuffer, cbuffer) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tcbuffer, tcbuffer) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = tcbuffer, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tcbuffer, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tcbuffer, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tcbuffer, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = cbuffer, RIGHTARG = tcbuffer, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tcbuffer, RIGHTARG = cbuffer, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tcbuffer, RIGHTARG = tcbuffer, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +/*****************************************************************************/ + +CREATE FUNCTION shortestLine(geometry, tcbuffer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(stbox, tcbuffer) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(cbuffer, tcbuffer) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tcbuffer, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tcbuffer, stbox) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tcbuffer, cbuffer) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tcbuffer, tcbuffer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/161_tcbuffer_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/161_tcbuffer_aggfuncs.in.sql new file mode 100644 index 0000000..0cea980 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/161_tcbuffer_aggfuncs.in.sql @@ -0,0 +1,155 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal circular buffers + */ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tcbuffer) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tcbuffer) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, tcbuffer, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(tcbuffer, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tcbuffer) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcbuffer_tagg_finalfn(internal) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(tcbuffer) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tcbuffer_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tcbuffer, tcbuffer, + interp text DEFAULT NULL) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tcbuffer, tcbuffer, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tcbuffer) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tcbuffer, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tcbuffer, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tcbuffer, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tcbuffer, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tcbuffer, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tcbuffer, tcbuffer) + RETURNS tcbuffer + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tcbuffer) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tcbuffer, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/162_tcbuffer_spatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/162_tcbuffer_spatialrels.in.sql new file mode 100644 index 0000000..1172008 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/162_tcbuffer_spatialrels.in.sql @@ -0,0 +1,364 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial relationships for temporal circular buffers + * @details These relationships are generalized to the temporal dimension with + * the "ever" and "always" semantics, and return a Boolean. + * + * The following relationships are supported: + * `eContains`, `aContains`, `eDisjoint`, `aDisjoint`, `eIntersects`, + * `aIntersects`, `eTouches`, `aTouches`, `eDwithin`, and `aDwithin` + * All these relationships, excepted `eDisjoint`, will automatically perform + * a bounding box comparison that will make use of any spatial, temporal, or + * spatiotemporal indexes that are available. + */ + +/***************************************************************************** + * eContains, aContains + *****************************************************************************/ + +/* eContains(geometry, tcbuffer) is not supported */ + +CREATE FUNCTION eContains(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eContains(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eContains(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aContains(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aContains(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aContains(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aContains(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eCovers, aCovers + *****************************************************************************/ + +/* eCovers(geometry, tcbuffer) is not supported */ + +CREATE FUNCTION eCovers(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eCovers(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eCovers(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aCovers(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aCovers(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aCovers(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aCovers(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDisjoint, aDisjoint + *****************************************************************************/ + +CREATE FUNCTION eDisjoint(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDisjoint(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDisjoint(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aDisjoint(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDisjoint(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDisjoint(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eIntersects, aIntersects + *****************************************************************************/ + +CREATE FUNCTION eintersects(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eintersects(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eIntersects(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eIntersects(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aIntersects(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aIntersects(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aIntersects(tcbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eTouches, aTouches + *****************************************************************************/ + +CREATE FUNCTION eTouches(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eTouches(tcbuffer, cbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eTouches(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eTouches(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aTouches(cbuffer, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aTouches(tcbuffer, cbuffer) + RETURNS boolean + SUPPORT tspatial_supportfn + AS 'MODULE_PATHNAME', 'Atouches_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aTouches(geometry, tcbuffer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aTouches(tcbuffer, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDwithin, aDwithin + *****************************************************************************/ + +CREATE FUNCTION eDwithin(cbuffer, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tcbuffer, cbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDwithin(geometry, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tcbuffer, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDwithin(tcbuffer, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aDwithin(cbuffer, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_cbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tcbuffer, cbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tcbuffer_cbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDwithin(geometry, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_geo_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tcbuffer, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tcbuffer_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDwithin(tcbuffer, tcbuffer, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tcbuffer_tcbuffer' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/164_tcbuffer_tempspatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/164_tcbuffer_tempspatialrels.in.sql new file mode 100644 index 0000000..6081434 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/164_tcbuffer_tempspatialrels.in.sql @@ -0,0 +1,186 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal spatial relationships for temporal circurlar buffers + */ + +/***************************************************************************** + * tContains + *****************************************************************************/ + +CREATE FUNCTION tContains(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(geometry, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(tcbuffer, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tContains + *****************************************************************************/ + +CREATE FUNCTION tCovers(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(geometry, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(tcbuffer, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDisjoint + *****************************************************************************/ + +CREATE FUNCTION tDisjoint(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(geometry, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tcbuffer, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tIntersects + *****************************************************************************/ + +CREATE FUNCTION tIntersects(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(geometry, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tcbuffer, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tTouches + *****************************************************************************/ + +CREATE FUNCTION tTouches(cbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tcbuffer, cbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(geometry, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_geo_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tcbuffer, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tcbuffer_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tcbuffer, tcbuffer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDwithin + *****************************************************************************/ + +CREATE FUNCTION tDwithin(cbuffer, tcbuffer, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_cbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tDwithin(tcbuffer, cbuffer, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tcbuffer_cbuffer' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- CREATE FUNCTION tDwithin(geometry, tcbuffer, dist float) + -- RETURNS tbool + -- AS 'MODULE_PATHNAME', 'Tdwithin_geo_tcbuffer' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION tDwithin(tcbuffer, geometry, dist float) + -- RETURNS tbool + -- AS 'MODULE_PATHNAME', 'Tdwithin_tcbuffer_geo' + -- LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tDwithin(tcbuffer, tcbuffer, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tcbuffer_tcbuffer' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/166_tcbuffer_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/166_tcbuffer_indexes.in.sql new file mode 100644 index 0000000..61dda3e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/166_tcbuffer_indexes.in.sql @@ -0,0 +1,266 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST and SP-GiST indexes for temporal circular buffers + */ + +/******************************************************************************/ + +CREATE FUNCTION tcbuffer_gist_consistent(internal, tcbuffer, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tcbuffer_rtree_ops + DEFAULT FOR TYPE tcbuffer USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (tcbuffer, stbox), + OPERATOR 1 << (tcbuffer, tcbuffer), + -- overlaps or left + OPERATOR 2 &< (tcbuffer, stbox), + OPERATOR 2 &< (tcbuffer, tcbuffer), + -- overlaps + OPERATOR 3 && (tcbuffer, tstzspan), + OPERATOR 3 && (tcbuffer, stbox), + OPERATOR 3 && (tcbuffer, tcbuffer), + -- overlaps or right + OPERATOR 4 &> (tcbuffer, stbox), + OPERATOR 4 &> (tcbuffer, tcbuffer), + -- strictly right + OPERATOR 5 >> (tcbuffer, stbox), + OPERATOR 5 >> (tcbuffer, tcbuffer), + -- same + OPERATOR 6 ~= (tcbuffer, tstzspan), + OPERATOR 6 ~= (tcbuffer, stbox), + OPERATOR 6 ~= (tcbuffer, tcbuffer), + -- contains + OPERATOR 7 @> (tcbuffer, tstzspan), + OPERATOR 7 @> (tcbuffer, stbox), + OPERATOR 7 @> (tcbuffer, tcbuffer), + -- contained by + OPERATOR 8 <@ (tcbuffer, tstzspan), + OPERATOR 8 <@ (tcbuffer, stbox), + OPERATOR 8 <@ (tcbuffer, tcbuffer), + -- overlaps or below + OPERATOR 9 &<| (tcbuffer, stbox), + OPERATOR 9 &<| (tcbuffer, tcbuffer), + -- strictly below + OPERATOR 10 <<| (tcbuffer, stbox), + OPERATOR 10 <<| (tcbuffer, tcbuffer), + -- strictly above + OPERATOR 11 |>> (tcbuffer, stbox), + OPERATOR 11 |>> (tcbuffer, tcbuffer), + -- overlaps or above + OPERATOR 12 |&> (tcbuffer, stbox), + OPERATOR 12 |&> (tcbuffer, tcbuffer), + -- adjacent + OPERATOR 17 -|- (tcbuffer, tstzspan), + OPERATOR 17 -|- (tcbuffer, stbox), + OPERATOR 17 -|- (tcbuffer, tcbuffer), + -- nearest approach distance +-- OPERATOR 25 |=| (tcbuffer, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tcbuffer, tstzspan), + OPERATOR 28 &<# (tcbuffer, stbox), + OPERATOR 28 &<# (tcbuffer, tcbuffer), + -- strictly before + OPERATOR 29 <<# (tcbuffer, tstzspan), + OPERATOR 29 <<# (tcbuffer, stbox), + OPERATOR 29 <<# (tcbuffer, tcbuffer), + -- strictly after + OPERATOR 30 #>> (tcbuffer, tstzspan), + OPERATOR 30 #>> (tcbuffer, stbox), + OPERATOR 30 #>> (tcbuffer, tcbuffer), + -- overlaps or after + OPERATOR 31 #&> (tcbuffer, tstzspan), + OPERATOR 31 #&> (tcbuffer, stbox), + OPERATOR 31 #&> (tcbuffer, tcbuffer), + -- functions + FUNCTION 1 tcbuffer_gist_consistent(internal, tcbuffer, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal); +-- FUNCTION 8 gist_tcbuffer_distance(internal, tcbuffer, smallint, oid, internal), + +/******************************************************************************/ + +CREATE OPERATOR CLASS tcbuffer_quadtree_ops + DEFAULT FOR TYPE tcbuffer USING spgist AS + -- strictly left + OPERATOR 1 << (tcbuffer, stbox), + OPERATOR 1 << (tcbuffer, tcbuffer), + -- overlaps or left + OPERATOR 2 &< (tcbuffer, stbox), + OPERATOR 2 &< (tcbuffer, tcbuffer), + -- overlaps + OPERATOR 3 && (tcbuffer, tstzspan), + OPERATOR 3 && (tcbuffer, stbox), + OPERATOR 3 && (tcbuffer, tcbuffer), + -- overlaps or right + OPERATOR 4 &> (tcbuffer, stbox), + OPERATOR 4 &> (tcbuffer, tcbuffer), + -- strictly right + OPERATOR 5 >> (tcbuffer, stbox), + OPERATOR 5 >> (tcbuffer, tcbuffer), + -- same + OPERATOR 6 ~= (tcbuffer, tstzspan), + OPERATOR 6 ~= (tcbuffer, stbox), + OPERATOR 6 ~= (tcbuffer, tcbuffer), + -- contains + OPERATOR 7 @> (tcbuffer, tstzspan), + OPERATOR 7 @> (tcbuffer, stbox), + OPERATOR 7 @> (tcbuffer, tcbuffer), + -- contained by + OPERATOR 8 <@ (tcbuffer, tstzspan), + OPERATOR 8 <@ (tcbuffer, stbox), + OPERATOR 8 <@ (tcbuffer, tcbuffer), + -- overlaps or below + OPERATOR 9 &<| (tcbuffer, stbox), + OPERATOR 9 &<| (tcbuffer, tcbuffer), + -- strictly below + OPERATOR 10 <<| (tcbuffer, stbox), + OPERATOR 10 <<| (tcbuffer, tcbuffer), + -- strictly above + OPERATOR 11 |>> (tcbuffer, stbox), + OPERATOR 11 |>> (tcbuffer, tcbuffer), + -- overlaps or above + OPERATOR 12 |&> (tcbuffer, stbox), + OPERATOR 12 |&> (tcbuffer, tcbuffer), + -- adjacent + OPERATOR 17 -|- (tcbuffer, tstzspan), + OPERATOR 17 -|- (tcbuffer, stbox), + OPERATOR 17 -|- (tcbuffer, tcbuffer), + -- nearest approach distance +-- OPERATOR 25 |=| (tcbuffer, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tcbuffer, tstzspan), + OPERATOR 28 &<# (tcbuffer, stbox), + OPERATOR 28 &<# (tcbuffer, tcbuffer), + -- strictly before + OPERATOR 29 <<# (tcbuffer, tstzspan), + OPERATOR 29 <<# (tcbuffer, stbox), + OPERATOR 29 <<# (tcbuffer, tcbuffer), + -- strictly after + OPERATOR 30 #>> (tcbuffer, tstzspan), + OPERATOR 30 #>> (tcbuffer, stbox), + OPERATOR 30 #>> (tcbuffer, tcbuffer), + -- overlaps or after + OPERATOR 31 #&> (tcbuffer, tstzspan), + OPERATOR 31 #&> (tcbuffer, stbox), + OPERATOR 31 #&> (tcbuffer, tcbuffer), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tcbuffer_kdtree_ops + FOR TYPE tcbuffer USING spgist AS + -- strictly left + OPERATOR 1 << (tcbuffer, stbox), + OPERATOR 1 << (tcbuffer, tcbuffer), + -- overlaps or left + OPERATOR 2 &< (tcbuffer, stbox), + OPERATOR 2 &< (tcbuffer, tcbuffer), + -- overlaps + OPERATOR 3 && (tcbuffer, tstzspan), + OPERATOR 3 && (tcbuffer, stbox), + OPERATOR 3 && (tcbuffer, tcbuffer), + -- overlaps or right + OPERATOR 4 &> (tcbuffer, stbox), + OPERATOR 4 &> (tcbuffer, tcbuffer), + -- strictly right + OPERATOR 5 >> (tcbuffer, stbox), + OPERATOR 5 >> (tcbuffer, tcbuffer), + -- same + OPERATOR 6 ~= (tcbuffer, tstzspan), + OPERATOR 6 ~= (tcbuffer, stbox), + OPERATOR 6 ~= (tcbuffer, tcbuffer), + -- contains + OPERATOR 7 @> (tcbuffer, tstzspan), + OPERATOR 7 @> (tcbuffer, stbox), + OPERATOR 7 @> (tcbuffer, tcbuffer), + -- contained by + OPERATOR 8 <@ (tcbuffer, tstzspan), + OPERATOR 8 <@ (tcbuffer, stbox), + OPERATOR 8 <@ (tcbuffer, tcbuffer), + -- overlaps or below + OPERATOR 9 &<| (tcbuffer, stbox), + OPERATOR 9 &<| (tcbuffer, tcbuffer), + -- strictly below + OPERATOR 10 <<| (tcbuffer, stbox), + OPERATOR 10 <<| (tcbuffer, tcbuffer), + -- strictly above + OPERATOR 11 |>> (tcbuffer, stbox), + OPERATOR 11 |>> (tcbuffer, tcbuffer), + -- overlaps or above + OPERATOR 12 |&> (tcbuffer, stbox), + OPERATOR 12 |&> (tcbuffer, tcbuffer), + -- adjacent + OPERATOR 17 -|- (tcbuffer, tstzspan), + OPERATOR 17 -|- (tcbuffer, stbox), + OPERATOR 17 -|- (tcbuffer, tcbuffer), + -- nearest approach distance +-- OPERATOR 25 |=| (tcbuffer, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tcbuffer, tstzspan), + OPERATOR 28 &<# (tcbuffer, stbox), + OPERATOR 28 &<# (tcbuffer, tcbuffer), + -- strictly before + OPERATOR 29 <<# (tcbuffer, tstzspan), + OPERATOR 29 <<# (tcbuffer, stbox), + OPERATOR 29 <<# (tcbuffer, tcbuffer), + -- strictly after + OPERATOR 30 #>> (tcbuffer, tstzspan), + OPERATOR 30 #>> (tcbuffer, stbox), + OPERATOR 30 #>> (tcbuffer, tcbuffer), + -- overlaps or after + OPERATOR 31 #&> (tcbuffer, tstzspan), + OPERATOR 31 #&> (tcbuffer, stbox), + OPERATOR 31 #&> (tcbuffer, tcbuffer), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/CMakeLists.txt new file mode 100644 index 0000000..7cade2d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/cbuffer/CMakeLists.txt @@ -0,0 +1,23 @@ +SET(LOCAL_FILES + 150_cbuffer + 151_cbufferset + 152_tcbuffer + # 153_tcbuffer_inout + 154_tcbuffer_compops + 155_tcbuffer_spatialfuncs + 158_tcbuffer_topops + 159_tcbuffer_posops + 160_tcbuffer_distance + 161_tcbuffer_aggfuncs + 162_tcbuffer_spatialrels + 164_tcbuffer_tempspatialrels + 166_tcbuffer_indexes + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/050_geoset.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/050_geoset.in.sql new file mode 100644 index 0000000..2404117 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/050_geoset.in.sql @@ -0,0 +1,944 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for set of geometry/geography values + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE geomset; +CREATE TYPE geogset; + +CREATE FUNCTION geomset_in(cstring) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomset_out(geomset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomset_recv(internal) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomset_send(geomset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geogset_in(cstring) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogset_out(geogset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogset_recv(internal) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogset_send(geogset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spatialset_analyze(internal) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spatialset_analyze' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE geomset ( + internallength = variable, + input = geomset_in, + output = geomset_out, + receive = geomset_recv, + send = geomset_send, + alignment = double, + storage = extended, + analyze = spatialset_analyze +); + +CREATE TYPE geogset ( + internallength = variable, + input = geogset_in, + output = geogset_out, + receive = geogset_recv, + send = geogset_send, + alignment = double, + storage = extended, + analyze = spatialset_analyze +); + +/******************************************************************************/ + +-- Input/output in WKB and HexWKB representation + +CREATE FUNCTION geomsetFromText(text) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomsetFromEWKT(text) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geogsetFromText(text) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogsetFromEWKT(text) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geomsetFromBinary(bytea) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomsetFromEWKB(bytea) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geomsetFromHexWKB(text) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geogsetFromBinary(bytea) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogsetFromEWKB(bytea) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geogsetFromHexWKB(text) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(geomset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(geomset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(geogset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(geogset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(geomset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(geomset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(geogset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(geogset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor + ******************************************************************************/ + +CREATE FUNCTION set(geometry[]) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(geography[]) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION set(geometry) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(geography) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (geometry AS geomset) WITH FUNCTION set(geometry); +CREATE CAST (geography AS geogset) WITH FUNCTION set(geography); + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION memSize(geomset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(geogset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numValues(geomset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(geogset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(geomset) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(geogset) + RETURNS geography + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(geomset) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(geogset) + RETURNS geography + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(geomset, integer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(geogset, integer) + RETURNS geography + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getValues(geomset) + RETURNS geometry[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(geogset) + RETURNS geography[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * SRID functions + *****************************************************************************/ + +CREATE FUNCTION SRID(geomset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spatialset_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION SRID(geogset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spatialset_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(geomset, integer) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Spatialset_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setSRID(geogset, integer) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Spatialset_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(geomset, integer) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Spatialset_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(geogset, integer) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Spatialset_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(geomset, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Spatialset_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(geogset, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Spatialset_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION round(geomset, integer DEFAULT 0) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(geogset, integer DEFAULT 0) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation set of values <-> set + ******************************************************************************/ + +CREATE FUNCTION unnest(geomset) + RETURNS SETOF geometry + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(geogset) + RETURNS SETOF geography + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, geometry) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, geography) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION set_union_transfn(internal, geomset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, geogset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION geomset_union_finalfn(internal) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION geogset_union_finalfn(internal) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE setUnion(geometry) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = geomset_union_finalfn +); +CREATE AGGREGATE setUnion(geography) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = geogset_union_finalfn +); + +CREATE AGGREGATE setUnion(geomset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = geomset_union_finalfn +); +CREATE AGGREGATE setUnion(geogset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = geogset_union_finalfn +); + +/***************************************************************************** + * Selectivity functions + *****************************************************************************/ + +-- CREATE FUNCTION spatialset_sel(internal, oid, internal, integer) + -- RETURNS float + -- AS 'MODULE_PATHNAME', 'Spatialset_sel' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION set_eq(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_ne(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_lt(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_le(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_ge(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gt(geomset, geomset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(geogset, geogset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_cmp(geomset, geomset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(geogset, geogset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >= + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR < ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >= + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +CREATE OPERATOR <= ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = > + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = > + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +CREATE OPERATOR >= ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = < + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = < + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +CREATE OPERATOR > ( + LEFTARG = geomset, RIGHTARG = geomset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <= + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR > ( + LEFTARG = geogset, RIGHTARG = geogset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <= + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +CREATE OPERATOR CLASS geomset_btree_ops + DEFAULT FOR TYPE geomset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(geomset, geomset); +CREATE OPERATOR CLASS geogset_btree_ops + DEFAULT FOR TYPE geogset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(geogset, geogset); + +/******************************************************************************/ + +CREATE FUNCTION set_hash(geomset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(geogset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_hash_extended(geomset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(geogset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS geomset_hash_ops + DEFAULT FOR TYPE geomset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(geomset), + FUNCTION 2 set_hash_extended(geomset, bigint); +CREATE OPERATOR CLASS geogset_hash_ops + DEFAULT FOR TYPE geogset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(geogset), + FUNCTION 2 set_hash_extended(geogset, bigint); + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION set_contains(geomset, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(geomset, geomset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(geogset, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(geogset, geogset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = geomset, RIGHTARG = geometry, + COMMUTATOR = <@ + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = <@ + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = geogset, RIGHTARG = geography, + COMMUTATOR = <@ + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = <@ + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_contained(geometry, geomset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(geomset, geomset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(geography, geogset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(geogset, geogset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = geometry, RIGHTARG = geomset, + COMMUTATOR = @> + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = @> + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = geography, RIGHTARG = geogset, + COMMUTATOR = @> + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = @> + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overlaps(geomset, geomset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(geogset, geogset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = && + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = && + -- RESTRICT = stbox_sel, JOIN = stbox_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION set_union(geometry, geomset) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(geomset, geometry) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(geomset, geomset) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(geography, geogset) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(geogset, geography) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(geogset, geogset) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geometry, RIGHTARG = geomset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geomset, RIGHTARG = geometry, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geography, RIGHTARG = geogset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geogset, RIGHTARG = geography, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION set_minus(geometry, geomset) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(geomset, geometry) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(geomset, geomset) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(geography, geogset) + RETURNS geography + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(geogset, geography) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(geogset, geogset) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geometry, RIGHTARG = geomset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geomset, RIGHTARG = geometry +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geomset, RIGHTARG = geomset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geography, RIGHTARG = geogset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geogset, RIGHTARG = geography +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = geogset, RIGHTARG = geogset +); + +/*****************************************************************************/ + +CREATE FUNCTION set_intersection(geometry, geomset) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(geomset, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(geomset, geomset) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(geography, geogset) + RETURNS geography + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(geogset, geography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(geogset, geogset) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geometry, RIGHTARG = geomset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geomset, RIGHTARG = geometry, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geography, RIGHTARG = geogset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geogset, RIGHTARG = geography, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = * +); + +/*****************************************************************************/ + +CREATE FUNCTION set_distance(geometry, geomset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(geomset, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(geomset, geomset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_distance(geography, geogset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(geogset, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(geogset, geogset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geometry, RIGHTARG = geomset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geomset, RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geomset, RIGHTARG = geomset, + COMMUTATOR = <-> +); + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geography, RIGHTARG = geogset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geogset, RIGHTARG = geography, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = geogset, RIGHTARG = geogset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/051_stbox.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/051_stbox.in.sql new file mode 100644 index 0000000..5ad6fff --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/051_stbox.in.sql @@ -0,0 +1,763 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for spatiotemporal bounding boxes + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE stbox; + +CREATE FUNCTION stbox_in(cstring) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_out(stbox) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Stbox_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_recv(internal) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_send(stbox) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Stbox_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE stbox ( + internallength = 80, + input = stbox_in, + output = stbox_out, + receive = stbox_recv, + send = stbox_send, + storage = plain, + alignment = double +); + +-- Input/output in WKB and HexWKB representation + +CREATE FUNCTION stboxFromBinary(bytea) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stboxFromHexWKB(text) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(stbox, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Stbox_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(stbox, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Stbox_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(stbox, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Stbox_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION stboxX(float, float, float, float, srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_x' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxZ(float, float, float, float, float, float, + srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_z' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxT(timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_t' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxT(tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_t' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxXT(float, float, float, float, timestamptz, + srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_xt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxXT(float, float, float, float, tstzspan, + srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_xt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxZT(float, float, float, float, float, float, + timestamptz, srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_zt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxZT(float, float, float, float, float, float, + tstzspan, srid integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_constructor_zt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geodstboxT(timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geodstbox_constructor_t' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geodstboxT(tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geodstbox_constructor_t' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geodstboxZ(float, float, float, float, float, float, + srid integer DEFAULT 4326) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geodstbox_constructor_z' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geodstboxZT(float, float, float, float, float, float, + timestamptz, srid integer DEFAULT 4326) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geodstbox_constructor_zt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geodstboxZT(float, float, float, float, float, float, + tstzspan, srid integer DEFAULT 4326) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geodstbox_constructor_zt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION stbox(geometry, timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geography, timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geometry, tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geography, tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Conversion + *****************************************************************************/ + +CREATE FUNCTION stbox(box2d) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Box2d_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(box3d) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Box3d_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geometry) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geography) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Geo_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geomset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Spatialset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(geogset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Spatialset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(tstzset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tstzset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(tstzspanset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tstzspanset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (box2d AS stbox) WITH FUNCTION stbox(box2d); +CREATE CAST (box3d AS stbox) WITH FUNCTION stbox(box3d); +CREATE CAST (geometry AS stbox) WITH FUNCTION stbox(geometry); +CREATE CAST (geography AS stbox) WITH FUNCTION stbox(geography); +CREATE CAST (geomset AS stbox) WITH FUNCTION stbox(geomset); +CREATE CAST (geogset AS stbox) WITH FUNCTION stbox(geogset); +CREATE CAST (timestamptz AS stbox) WITH FUNCTION stbox(timestamptz); +CREATE CAST (tstzset AS stbox) WITH FUNCTION stbox(tstzset); +CREATE CAST (tstzspan AS stbox) WITH FUNCTION stbox(tstzspan); +CREATE CAST (tstzspanset AS stbox) WITH FUNCTION stbox(tstzspanset); + +/*****************************************************************************/ + +CREATE FUNCTION box2d(stbox) + RETURNS box2d + AS 'MODULE_PATHNAME', 'Stbox_to_box2d' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION box3d(stbox) + RETURNS box3d + AS 'MODULE_PATHNAME', 'Stbox_to_box3d' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geometry(stbox) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Stbox_to_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geography(stbox) + RETURNS geography + AS 'MODULE_PATHNAME', 'Stbox_to_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(stbox) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Stbox_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (stbox AS box2d) WITH FUNCTION box2d(stbox); +CREATE CAST (stbox AS box3d) WITH FUNCTION box3d(stbox); +CREATE CAST (stbox AS geometry) WITH FUNCTION geometry(stbox); +CREATE CAST (stbox AS geography) WITH FUNCTION geography(stbox); +CREATE CAST (stbox AS tstzspan) WITH FUNCTION timeSpan(stbox); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +CREATE FUNCTION hasX(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_hasx' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION hasZ(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_hasz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION hasT(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_hast' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION isGeodetic(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_isgeodetic' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION Xmin(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_xmin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Ymin(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_ymin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Zmin(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_zmin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Tmin(stbox) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Stbox_tmin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION TminInc(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_tmin_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION Xmax(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_xmax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Ymax(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_ymax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Zmax(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_zmax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Tmax(stbox) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Stbox_tmax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION TmaxInc(stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_tmax_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION area(stbox, spheroid bool DEFAULT true) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_area' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION volume(stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_volume' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION perimeter(stbox, spheroid bool DEFAULT true) + RETURNS float + AS 'MODULE_PATHNAME', 'Stbox_perimeter' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION shiftTime(stbox, interval) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(stbox, interval) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(stbox, interval, interval) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getSpace(stbox) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_get_space' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION expandSpace(stbox, float) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_expand_space' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expandTime(stbox, interval) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_expand_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Selectively functions for operators + *****************************************************************************/ + +CREATE FUNCTION tspatial_sel(internal, oid, internal, integer) + RETURNS float +AS 'MODULE_PATHNAME', 'Tspatial_sel' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION tspatial_joinsel(internal, oid, internal, smallint, internal) + RETURNS float +AS 'MODULE_PATHNAME', 'Tspatial_joinsel' + LANGUAGE C IMMUTABLE STRICT; + +/***************************************************************************** +* Topological operators +*****************************************************************************/ + +CREATE FUNCTION stbox_contains(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_contained(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overlaps(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_same(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_adjacent(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = stbox_contains, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = stbox_contained, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = stbox_overlaps, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = stbox_same, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = stbox_adjacent, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** +* Position operators +*****************************************************************************/ + +CREATE FUNCTION stbox_left(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overleft(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_right(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overright(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_below(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overbelow(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_above(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overabove(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_before(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overbefore(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_after(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overafter(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_front(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overfront(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_back(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_overback(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = stbox_left, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = stbox_overleft, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = stbox_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = stbox_overright, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + PROCEDURE = stbox_below, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + PROCEDURE = stbox_overbelow, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + PROCEDURE = stbox_above, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + PROCEDURE = stbox_overabove, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = stbox_back, + COMMUTATOR = < ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = stbox_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = stbox_before, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = stbox_overbefore, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = stbox_after, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = stbox_overafter, + LEFTARG = stbox, RIGHTARG = stbox, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Set operators + *****************************************************************************/ + +CREATE FUNCTION stbox_union(stbox, stbox) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Union_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_intersection(stbox, stbox) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Intersection_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = stbox_union, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = + +); +CREATE OPERATOR * ( + PROCEDURE = stbox_intersection, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = * +); + +/***************************************************************************** + * Split functions + *****************************************************************************/ + +CREATE FUNCTION quadSplit(stbox) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Stbox_quad_split' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Extent aggreation + *****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION stbox_extent_transfn(stbox, stbox) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION stbox_extent_combinefn(stbox, stbox) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(stbox) ( + SFUNC = stbox_extent_transfn, + STYPE = stbox, + COMBINEFUNC = stbox_extent_combinefn, + PARALLEL = safe +); + +/***************************************************************************** + * Comparison + *****************************************************************************/ + +CREATE FUNCTION stbox_eq(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_ne(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_lt(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_le(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_ge(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_gt(stbox, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Stbox_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_cmp(stbox, stbox) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Stbox_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = stbox_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = stbox_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = stbox_lt, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = stbox_le, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = stbox_ge, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR > ( + PROCEDURE = stbox_gt, + LEFTARG = stbox, RIGHTARG = stbox, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = areasel, JOIN = areajoinsel +); + +CREATE OPERATOR CLASS stbox_btree_ops + DEFAULT FOR TYPE stbox USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 stbox_cmp(stbox, stbox); + +/*****************************************************************************/ + +CREATE FUNCTION stbox_hash(stbox) + RETURNS integer + AS 'MODULE_PATHNAME', 'Stbox_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox_hash_extended(stbox, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Stbox_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS stbox_hash_ops + DEFAULT FOR TYPE stbox USING hash AS + OPERATOR 1 = , + FUNCTION 1 stbox_hash(stbox), + FUNCTION 2 stbox_hash_extended(stbox, bigint); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tgeo.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tgeo.in.sql new file mode 100644 index 0000000..b705b6b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tgeo.in.sql @@ -0,0 +1,1081 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal geometry/geographies + */ + +CREATE TYPE tgeometry; +CREATE TYPE tgeography; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION tgeometry_in(cstring, oid, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeo_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tgeometry) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeometry_recv(internal, oid, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tgeometry) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometry_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tgeometry_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tgeography_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tspatial_typmod_out(integer) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Tspatial_typmod_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tspatial_analyze(internal) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tspatial_analyze' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tgeometry ( + internallength = variable, + input = tgeometry_in, + output = temporal_out, + send = temporal_send, + receive = tgeometry_recv, + typmod_in = tgeometry_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +CREATE FUNCTION tgeography_in(cstring, oid, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tgeo_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tgeography) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography_recv(internal, oid, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tgeography) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tgeography ( + internallength = variable, + input = tgeography_in, + output = temporal_out, + send = temporal_send, + receive = tgeography_recv, + typmod_in = tgeography_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tgeometry(tgeometry, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(tgeography, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeometry AS tgeometry) WITH FUNCTION tgeometry(tgeometry, integer) AS IMPLICIT; +CREATE CAST (tgeography AS tgeography) WITH FUNCTION tgeography(tgeography, integer) AS IMPLICIT; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION tgeometry(geometry, timestamptz) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeoinst_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(geography, timestamptz) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tgeoinst_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometry(geometry, tstzset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(geography, tstzset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometry(geometry, tstzspan, text DEFAULT 'step') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(geography, tstzspan, text DEFAULT 'step') + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometry(geometry, tstzspanset, text DEFAULT 'step') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(geography, tstzspanset, text DEFAULT 'step') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tgeometrySeq(tgeometry[], text DEFAULT 'step', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographySeq(tgeography[], text DEFAULT 'step', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometrySeqSet(tgeometry[]) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographySeqSet(tgeography[]) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tgeometrySeqSetGaps(tgeometry[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'step') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tgeographySeqSetGaps(tgeography[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'step') + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/****************************************************************************** + * Conversions + ******************************************************************************/ + +CREATE FUNCTION timeSpan(tgeometry) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tgeography) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeometry AS tstzspan) WITH FUNCTION timeSpan(tgeometry); +CREATE CAST (tgeography AS tstzspan) WITH FUNCTION timeSpan(tgeography); + +/****************************************************************************** + * Transformations + ******************************************************************************/ + +CREATE FUNCTION tgeometryInst(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeometrySeq(tgeometry, text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeometrySeq(tgeometry) + RETURNS tgeometry + AS 'SELECT @extschema@.tgeometrySeq($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeometrySeqSet(tgeometry, text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeometrySeqSet(tgeometry) + RETURNS tgeometry + AS 'SELECT @extschema@.tgeometrySeqSet($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tgeographyInst(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeographySeq(tgeography, text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeographySeq(tgeography) + RETURNS tgeography + AS 'SELECT @extschema@.tgeographySeq($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeographySeqSet(tgeography, text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeographySeqSet(tgeography) + RETURNS tgeography + AS 'SELECT @extschema@.tgeographySeqSet($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tgeometry, text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setInterp(tgeography, text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION merge(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION merge(tgeometry[]) + RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tgeography[]) + RETURNS tgeography +AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor Functions + ******************************************************************************/ + +CREATE FUNCTION tempSubtype(tgeometry) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tempSubtype(tgeography) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tgeometry) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION interp(tgeography) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValue(tgeography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- There is no getValues() function for temporal geos, +-- it is called traversedArea() for temporal geos + +CREATE FUNCTION getTimestamp(tgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTimestamp(tgeography) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueSet(tgeometry) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueSet(tgeography) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tgeometry, integer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(tgeography, integer) + RETURNS geography + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tgeometry) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTime(tgeography) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(tgeography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(tgeography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tgeometry, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tgeography, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numInstants(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startInstant(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endInstant(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tgeometry, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instantN(tgeography, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tgeometry) + RETURNS tgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instants(tgeography) + RETURNS tgeography[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numTimestamps(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startTimestamp(tgeography) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endTimestamp(tgeography) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tgeometry, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestampN(tgeography, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tgeometry) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestamps(tgeography) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSequences(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSequence(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSequence(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tgeometry, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequenceN(tgeography, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tgeometry) + RETURNS tgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequences(tgeography) + RETURNS tgeography[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tgeometry) + RETURNS tgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segments(tgeography) + RETURNS tgeography[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Shift and scale functions + *****************************************************************************/ + +CREATE FUNCTION shiftTime(tgeometry, interval) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(tgeography, interval) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tgeometry, interval) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(tgeography, interval) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tgeometry, interval, interval) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(tgeography, interval, interval) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tprecision(tgeometry, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tprecision(tgeography, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tsample(tgeometry, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tsample(tgeography, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE FUNCTION unnest(tgeometry) + RETURNS SETOF geom_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(tgeography) + RETURNS SETOF geog_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction Functions + *****************************************************************************/ + +CREATE FUNCTION atValues(tgeometry, geometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tgeography, geography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tgeometry, geometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tgeography, geography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tgeometry, geomset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tgeography, geogset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tgeometry, geomset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tgeography, geogset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeometry, timestamptz) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeography, timestamptz) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeometry, timestamptz) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeography, timestamptz) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tgeometry, timestamptz) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueAtTimestamp(tgeography, timestamptz) + RETURNS geography + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeometry, tstzset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeography, tstzset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeometry, tstzset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeography, tstzset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeometry, tstzspan) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeography, tstzspan) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeometry, tstzspan) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeography, tstzspan) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeometry, tstzspanset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeography, tstzspanset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeometry, tstzspanset) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeography, tstzspanset) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tgeometry, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION beforeTimestamp(tgeography, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tgeometry, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION afterTimestamp(tgeography, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tgeometry, tgeometry, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION insert(tgeography, tgeometry, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tgeometry, tgeometry, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION update(tgeography, tgeography, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeometry, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeography, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeometry, tstzset, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeography, tstzset, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeometry, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeography, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeometry, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeography, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stops Function + *****************************************************************************/ + +-- CREATE FUNCTION stops(tgeometry, maxdist float DEFAULT 0.0, + -- minduration interval DEFAULT '0 minutes') + -- RETURNS tgeometry + -- AS 'MODULE_PATHNAME', 'Temporal_stops' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION stops(tgeography, maxdist float DEFAULT 0.0, + -- minduration interval DEFAULT '0 minutes') + -- RETURNS tgeography + -- AS 'MODULE_PATHNAME', 'Temporal_stops' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION stops(tgeometry, minduration interval DEFAULT '0 minutes') + -- RETURNS tgeometry + -- AS 'SELECT @extschema@.stops($1, 0.0, $2)' + -- LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION stops(tgeography, minduration interval DEFAULT '0 minutes') + -- RETURNS tgeography + -- AS 'SELECT @extschema@.stops($1, 0.0, $2)' + -- LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE time_tgeom AS ( + time timestamptz, + tgeom tgeometry +); +CREATE TYPE time_tgeog AS ( + time timestamptz, + tgeog tgeography +); + +CREATE FUNCTION timeSplit(tgeometry, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tgeom + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeSplit(tgeography, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tgeog + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tgeometry, tgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tgeometry, tgeometry) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE OPERATOR CLASS tgeometry_btree_ops + DEFAULT FOR TYPE tgeometry USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tgeometry, tgeometry); + +/******************************************************************************/ + +CREATE FUNCTION temporal_lt(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tgeography, tgeography) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tgeography, tgeography) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <> ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE OPERATOR CLASS tgeography_btree_ops + DEFAULT FOR TYPE tgeography USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tgeography, tgeography); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_hash(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tgeometry_hash_ops + DEFAULT FOR TYPE tgeometry USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tgeometry); +CREATE OPERATOR CLASS tgeography_hash_ops + DEFAULT FOR TYPE tgeography USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tgeography); + +/******************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tpoint.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tpoint.in.sql new file mode 100644 index 0000000..4d3383e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/052_tpoint.in.sql @@ -0,0 +1,1082 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal geometry/geography points + */ + +CREATE TYPE tgeompoint; +CREATE TYPE tgeogpoint; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION tgeompoint_in(cstring, oid, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpoint_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tgeompoint) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeompoint_recv(internal, oid, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tgeompoint) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompoint_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tgeompoint_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tgeompoint ( + internallength = variable, + input = tgeompoint_in, + output = temporal_out, + send = temporal_send, + receive = tgeompoint_recv, + typmod_in = tgeompoint_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +CREATE FUNCTION tgeogpoint_in(cstring, oid, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tpoint_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tgeogpoint) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint_recv(internal, oid, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tgeogpoint) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeogpoint_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tgeogpoint_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tgeogpoint ( + internallength = variable, + input = tgeogpoint_in, + output = temporal_out, + send = temporal_send, + receive = tgeogpoint_recv, + typmod_in = tgeogpoint_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tgeompoint(tgeompoint, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(tgeogpoint, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeompoint AS tgeompoint) WITH FUNCTION tgeompoint(tgeompoint, integer) AS IMPLICIT; +CREATE CAST (tgeogpoint AS tgeogpoint) WITH FUNCTION tgeogpoint(tgeogpoint, integer) AS IMPLICIT; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION tgeompoint(geometry(Point), timestamptz) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpointinst_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(geography(Point), timestamptz) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tpointinst_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompoint(geometry, tstzset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(geography, tstzset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompoint(geometry, tstzspan, text DEFAULT 'linear') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(geography, tstzspan, text DEFAULT 'linear') + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompoint(geometry, tstzspanset, text DEFAULT 'linear') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(geography, tstzspanset, text DEFAULT 'linear') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tgeompointSeq(tgeompoint[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointSeq(tgeogpoint[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointSeqSet(tgeompoint[]) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointSeqSet(tgeogpoint[]) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tgeompointSeqSetGaps(tgeompoint[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tgeogpointSeqSetGaps(tgeogpoint[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/****************************************************************************** + * Conversions + ******************************************************************************/ + +CREATE FUNCTION timeSpan(tgeompoint) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tgeogpoint) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeompoint AS tstzspan) WITH FUNCTION timeSpan(tgeompoint); +CREATE CAST (tgeogpoint AS tstzspan) WITH FUNCTION timeSpan(tgeogpoint); + +/****************************************************************************** + * Transformations + ******************************************************************************/ + +CREATE FUNCTION tgeompointInst(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeompointSeq(tgeompoint, text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeompointSeq(tgeompoint) + RETURNS tgeompoint + AS 'SELECT @extschema@.tgeompointSeq($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeompointSeqSet(tgeompoint, text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeompointSeqSet(tgeompoint) + RETURNS tgeompoint + AS 'SELECT @extschema@.tgeompointSeqSet($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tgeogpointInst(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeogpointSeq(tgeogpoint, text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeogpointSeq(tgeogpoint) + RETURNS tgeogpoint + AS 'SELECT @extschema@.tgeogpointSeq($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeogpointSeqSet(tgeogpoint, text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tgeogpointSeqSet(tgeogpoint) + RETURNS tgeogpoint + AS 'SELECT @extschema@.tgeogpointSeqSet($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tgeompoint, text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setInterp(tgeogpoint, text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION merge(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION merge(tgeompoint[]) + RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tgeogpoint[]) + RETURNS tgeogpoint +AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor Functions + ******************************************************************************/ + +CREATE FUNCTION tempSubtype(tgeompoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tempSubtype(tgeogpoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tgeompoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION interp(tgeogpoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(tgeompoint) + RETURNS geometry(Point) + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValue(tgeogpoint) + RETURNS geography(Point) + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- There is no getValues() function for temporal points, +-- it is called trajectory() for temporal points + +CREATE FUNCTION getTimestamp(tgeompoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTimestamp(tgeogpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueSet(tgeompoint) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueSet(tgeogpoint) + RETURNS geogset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tgeompoint, integer) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(tgeogpoint, integer) + RETURNS geography + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tgeompoint) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTime(tgeogpoint) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tgeompoint) + RETURNS geometry(Point) + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(tgeogpoint) + RETURNS geography(Point) + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tgeompoint) + RETURNS geometry(Point) + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(tgeogpoint) + RETURNS geography(Point) + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tgeompoint, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tgeogpoint, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numInstants(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startInstant(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endInstant(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tgeompoint, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instantN(tgeogpoint, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tgeompoint) + RETURNS tgeompoint[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instants(tgeogpoint) + RETURNS tgeogpoint[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numTimestamps(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tgeompoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startTimestamp(tgeogpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tgeompoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endTimestamp(tgeogpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tgeompoint, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestampN(tgeogpoint, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tgeompoint) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestamps(tgeogpoint) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSequences(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSequence(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSequence(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tgeompoint, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequenceN(tgeogpoint, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tgeompoint) + RETURNS tgeompoint[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequences(tgeogpoint) + RETURNS tgeogpoint[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tgeompoint) + RETURNS tgeompoint[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segments(tgeogpoint) + RETURNS tgeogpoint[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Shift and scale functions + *****************************************************************************/ + +CREATE FUNCTION shiftTime(tgeompoint, interval) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(tgeogpoint, interval) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tgeompoint, interval) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(tgeogpoint, interval) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tgeompoint, interval, interval) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(tgeogpoint, interval, interval) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tprecision(tgeompoint, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tprecision(tgeogpoint, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tsample(tgeompoint, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tsample(tgeogpoint, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE TYPE geom_tstzspanset AS ( + value geometry, + time tstzspanset +); +CREATE TYPE geog_tstzspanset AS ( + value geography, + time tstzspanset +); + +CREATE FUNCTION unnest(tgeompoint) + RETURNS SETOF geom_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(tgeogpoint) + RETURNS SETOF geog_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction Functions + *****************************************************************************/ + +CREATE FUNCTION atValues(tgeompoint, geometry(Point)) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tgeogpoint, geography(Point)) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tgeompoint, geometry(Point)) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tgeogpoint, geography(Point)) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tgeompoint, geomset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tgeogpoint, geogset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tgeompoint, geomset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tgeogpoint, geogset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeompoint, timestamptz) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeogpoint, timestamptz) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeompoint, timestamptz) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeogpoint, timestamptz) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tgeompoint, timestamptz) + RETURNS geometry(Point) + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueAtTimestamp(tgeogpoint, timestamptz) + RETURNS geography(Point) + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeompoint, tstzset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeogpoint, tstzset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeompoint, tstzset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeogpoint, tstzset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeompoint, tstzspan) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeogpoint, tstzspan) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeompoint, tstzspan) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeogpoint, tstzspan) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tgeompoint, tstzspanset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tgeogpoint, tstzspanset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tgeompoint, tstzspanset) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tgeogpoint, tstzspanset) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tgeompoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION beforeTimestamp(tgeogpoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tgeompoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION afterTimestamp(tgeogpoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tgeompoint, tgeompoint, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION insert(tgeogpoint, tgeompoint, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tgeompoint, tgeompoint, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION update(tgeogpoint, tgeogpoint, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeompoint, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeogpoint, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeompoint, tstzset, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeogpoint, tstzset, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeompoint, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeogpoint, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tgeompoint, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tgeogpoint, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stops Function + *****************************************************************************/ + +CREATE FUNCTION stops(tgeompoint, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stops(tgeogpoint, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stops(tgeompoint, minduration interval) + RETURNS tgeompoint + AS 'SELECT @extschema@.stops($1, 0.0, $2)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stops(tgeogpoint, minduration interval) + RETURNS tgeogpoint + AS 'SELECT @extschema@.stops($1, 0.0, $2)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE time_tgeompoint AS ( + time timestamptz, + temp tgeompoint +); +CREATE TYPE time_tgeogpoint AS ( + time timestamptz, + temp tgeogpoint +); + +CREATE FUNCTION timeSplit(tgeompoint, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeSplit(tgeogpoint, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tgeompoint, tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tgeompoint, tgeompoint) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE OPERATOR CLASS tgeompoint_btree_ops + DEFAULT FOR TYPE tgeompoint USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tgeompoint, tgeompoint); + +/******************************************************************************/ + +CREATE FUNCTION temporal_lt(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tgeogpoint, tgeogpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tgeogpoint, tgeogpoint) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <> ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE OPERATOR CLASS tgeogpoint_btree_ops + DEFAULT FOR TYPE tgeogpoint USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tgeogpoint, tgeogpoint); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_hash(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tgeompoint_hash_ops + DEFAULT FOR TYPE tgeompoint USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tgeompoint); +CREATE OPERATOR CLASS tgeogpoint_hash_ops + DEFAULT FOR TYPE tgeogpoint USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tgeogpoint); + +/******************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tgeo_inout.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tgeo_inout.in.sql new file mode 100644 index 0000000..dd3ff9d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tgeo_inout.in.sql @@ -0,0 +1,172 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Input/output of temporal geometries/geographies in WKT, EWKT, and + * MF-JSON representation + */ + +/***************************************************************************** + * Input + *****************************************************************************/ + +CREATE FUNCTION tgeometryFromText(text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromText(text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometryFromEWKT(text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromEWKT(text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometryFromMFJSON(text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromMFJSON(text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometryFromBinary(bytea) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromBinary(bytea) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometryFromEWKB(bytea) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromEWKB(bytea) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeometryFromHexEWKB(text) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeographyFromHexEWKB(text) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Output + *****************************************************************************/ + +CREATE FUNCTION asText(tgeometry, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tgeometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(tgeography, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tgeography[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tgeometry, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tgeometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tgeography, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tgeography[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asMFJSON(tgeometry, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asMFJSON(tgeography, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tgeometry, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tgeography, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(tgeometry, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKB(tgeography, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(tgeometry, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexEWKB(tgeography, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tpoint_inout.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tpoint_inout.in.sql new file mode 100644 index 0000000..ce4358d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/053_tpoint_inout.in.sql @@ -0,0 +1,190 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Input/output of temporal points in WKT, EWKT, and MF-JSON + * representation + */ + +/***************************************************************************** + * Input + *****************************************************************************/ + +CREATE FUNCTION tgeompointFromText(text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromText(text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tpoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointFromEWKT(text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromEWKT(text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tpoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointFromMFJSON(text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromMFJSON(text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointFromBinary(bytea) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromBinary(bytea) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointFromEWKB(bytea) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromEWKB(bytea) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tgeompointFromHexEWKB(text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpointFromHexEWKB(text) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Output + *****************************************************************************/ + +CREATE FUNCTION asText(tgeompoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tgeompoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(tgeogpoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tgeogpoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(geometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(geography[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tgeompoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tgeompoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tgeogpoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tgeogpoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(geometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(geography[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asMFJSON(tgeompoint, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asMFJSON(tgeogpoint, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tgeompoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tgeogpoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(tgeompoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKB(tgeogpoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(tgeompoint, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexEWKB(tgeogpoint, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tgeo_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tgeo_compops.in.sql new file mode 100644 index 0000000..07c6c49 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tgeo_compops.in.sql @@ -0,0 +1,457 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever/always and temporal comparison functions and operators for + * temporal geometries/geographies + */ + +/***************************************************************************** + * Index Support Function + *****************************************************************************/ + +CREATE FUNCTION tspatial_supportfn(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tspatial_supportfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = geometry, RIGHTARG = tgeometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = geography, RIGHTARG = tgeography, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = geometry, RIGHTARG = tgeometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = geography, RIGHTARG = tgeography, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = geometry, RIGHTARG = tgeometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = geography, RIGHTARG = tgeography, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = geometry, RIGHTARG = tgeometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = geography, RIGHTARG = tgeography, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tgeometry, RIGHTARG = geometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tgeography, RIGHTARG = geography, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tgeometry, RIGHTARG = geometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tgeography, RIGHTARG = geography, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tgeometry, RIGHTARG = geometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tgeography, RIGHTARG = geography, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tgeometry, RIGHTARG = geometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tgeography, RIGHTARG = geography, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal equal + *****************************************************************************/ + +CREATE FUNCTION tgeo_teq(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = geometry, RIGHTARG = tgeometry, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeometry, RIGHTARG = geometry, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +CREATE FUNCTION tgeo_teq(geography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeography, geography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = geography, RIGHTARG = tgeography, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeography, RIGHTARG = geography, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal not equal + *****************************************************************************/ + +CREATE FUNCTION tgeo_tne(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = geometry, RIGHTARG = tgeometry, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeometry, RIGHTARG = geometry, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = #<> +); + +/*****************************************************************************/ + +CREATE FUNCTION tgeo_tne(geography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeography, geography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = geography, RIGHTARG = tgeography, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeography, RIGHTARG = geography, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = #<> +); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tpoint_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tpoint_compops.in.sql new file mode 100644 index 0000000..30ba5d3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/054_tpoint_compops.in.sql @@ -0,0 +1,448 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever/always and temporal comparison functions and operators for + * temporal geometry/geography points + */ + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = geometry, RIGHTARG = tgeompoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = geography, RIGHTARG = tgeogpoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = geography, RIGHTARG = tgeogpoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = geometry, RIGHTARG = tgeompoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = geometry, RIGHTARG = tgeompoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = geography, RIGHTARG = tgeogpoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = geometry, RIGHTARG = tgeompoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = geography, RIGHTARG = tgeogpoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tgeompoint, RIGHTARG = geometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tgeogpoint, RIGHTARG = geography, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tgeogpoint, RIGHTARG = geography, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tgeompoint, RIGHTARG = geometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tgeompoint, RIGHTARG = geometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tgeogpoint, RIGHTARG = geography, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tgeompoint, RIGHTARG = geometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tgeogpoint, RIGHTARG = geography, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_eq(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal equal + *****************************************************************************/ + +CREATE FUNCTION tgeo_teq(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeompoint, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeompoint, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = geometry, RIGHTARG = tgeompoint, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeompoint, RIGHTARG = geometry, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +CREATE FUNCTION tgeo_teq(geography, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeogpoint, geography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_teq(tgeogpoint, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = geography, RIGHTARG = tgeogpoint, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeogpoint, RIGHTARG = geography, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = tgeo_teq, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal not equal + *****************************************************************************/ + +CREATE FUNCTION tgeo_tne(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeompoint, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeompoint, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = geometry, RIGHTARG = tgeompoint, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeompoint, RIGHTARG = geometry, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = #<> +); + +/*****************************************************************************/ + +CREATE FUNCTION tgeo_tne(geography, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeogpoint, geography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeo_tne(tgeogpoint, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = geography, RIGHTARG = tgeogpoint, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeogpoint, RIGHTARG = geography, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = tgeo_tne, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = #<> +); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tgeo_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tgeo_spatialfuncs.in.sql new file mode 100644 index 0000000..f2e859a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tgeo_spatialfuncs.in.sql @@ -0,0 +1,182 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial functions for temporal geometries/gepgraphies + */ + +/*****************************************************************************/ + +CREATE FUNCTION SRID(tgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION SRID(tgeography) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tgeometry, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(tgeometry, integer) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(tgeometry, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tgeography, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(tgeography, integer) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(tgeography, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION tgeography(tgeometry) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tgeometry_to_tgeography' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeometry(tgeography) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeography_to_tgeometry' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeometry AS tgeography) WITH FUNCTION tgeography(tgeometry); +CREATE CAST (tgeography AS tgeometry) WITH FUNCTION tgeometry(tgeography); + +CREATE FUNCTION tgeompoint(tgeometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_to_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeometry(tgeompoint) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tpoint_to_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint(tgeography) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tgeo_to_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography(tgeogpoint) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Tpoint_to_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeometry AS tgeompoint) WITH FUNCTION tgeompoint(tgeometry); +CREATE CAST (tgeompoint AS tgeometry) WITH FUNCTION tgeometry(tgeompoint); +CREATE CAST (tgeography AS tgeogpoint) WITH FUNCTION tgeogpoint(tgeography); +CREATE CAST (tgeogpoint AS tgeography) WITH FUNCTION tgeography(tgeogpoint); + +/*****************************************************************************/ + +CREATE FUNCTION round(tgeometry, integer DEFAULT 0) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tgeography, integer DEFAULT 0) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tgeometry[], integer DEFAULT 0) + RETURNS tgeometry[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tgeography[], integer DEFAULT 0) + RETURNS tgeography[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION traversedArea(tgeometry, bool DEFAULT FALSE) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tgeo_traversed_area' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION traversedArea(tgeography, bool DEFAULT FALSE) + RETURNS geography + AS 'MODULE_PATHNAME', 'Tgeo_traversed_area' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION centroid(tgeometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_centroid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION centroid(tgeography) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tgeo_centroid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION convexHull(tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tgeo_convex_hull' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION tCentroid(tgeometry) + -- RETURNS tgeometry + -- AS 'MODULE_PATHNAME', 'Tgeo_tcentroid' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION atGeometry(tgeometry, geometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeo_at_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusGeometry(tgeometry, geometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeo_minus_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atStbox(tgeometry, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeo_at_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusStbox(tgeometry, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Tgeo_minus_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tpoint_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tpoint_spatialfuncs.in.sql new file mode 100644 index 0000000..0382605 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/056_tpoint_spatialfuncs.in.sql @@ -0,0 +1,354 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial functions for temporal points + */ + +/*****************************************************************************/ + +CREATE FUNCTION round(stbox, integer DEFAULT 0) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(stbox[], integer DEFAULT 0) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Stboxarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(geometry, integer DEFAULT 0) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Geo_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(geography, integer DEFAULT 0) + RETURNS geography + AS 'MODULE_PATHNAME', 'Geo_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION SRID(stbox) + RETURNS integer + AS 'MODULE_PATHNAME', 'Stbox_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setSRID(stbox, integer) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(stbox, integer) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(stbox, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION SRID(tgeompoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION SRID(tgeogpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tgeompoint, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(tgeompoint, integer) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(tgeompoint, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tgeogpoint, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transform(tgeogpoint, integer) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION transformPipeline(tgeogpoint, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- Gauss Kruger transformation + +CREATE FUNCTION transform_gk(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeompoint_transform_gk' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform_gk(geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Geometry_transform_gk' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION tgeogpoint(tgeompoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tgeometry_to_tgeography' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeompoint(tgeogpoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeography_to_tgeometry' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeompoint AS tgeogpoint) WITH FUNCTION tgeogpoint(tgeompoint); +CREATE CAST (tgeogpoint AS tgeompoint) WITH FUNCTION tgeompoint(tgeogpoint); + +CREATE FUNCTION getX(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_x' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getX(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_x' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getY(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_y' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getY(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_y' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getZ(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_z' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getZ(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_get_z' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tgeompoint, integer DEFAULT 0) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tgeogpoint, integer DEFAULT 0) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tgeompoint[], integer DEFAULT 0) + RETURNS tgeompoint[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tgeogpoint[], integer DEFAULT 0) + RETURNS tgeogpoint[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trajectory(tgeompoint, bool DEFAULT FALSE) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tpoint_trajectory' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trajectory(tgeogpoint, bool DEFAULT FALSE) + RETURNS geography + AS 'MODULE_PATHNAME', 'Tpoint_trajectory' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION length(tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tpoint_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION length(tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tpoint_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION cumulativeLength(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_cumulative_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION cumulativeLength(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_cumulative_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION convexHull(tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tgeo_convex_hull' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION speed(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_derivative' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION speed(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_derivative' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION twCentroid(tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tpoint_twcentroid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION direction(tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tpoint_direction' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION direction(tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tpoint_direction' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION tdirection(tgeompoint) + -- RETURNS tfloat + -- AS 'MODULE_PATHNAME', 'Tpoint_tdirection' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION tdirection(tgeogpoint) + -- RETURNS tfloat + -- AS 'MODULE_PATHNAME', 'Tpoint_tdirection' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION azimuth(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_azimuth' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION azimuth(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_azimuth' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION angularDifference(tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_angular_difference' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION angularDifference(tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpoint_angular_difference' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The following two functions are meant to be included in PostGIS one day +CREATE FUNCTION bearing(geometry, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'Bearing_point_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bearing(geography, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'Bearing_point_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION bearing(geometry, tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Bearing_point_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bearing(tgeompoint, geometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Bearing_tpoint_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bearing(tgeompoint, tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Bearing_tpoint_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION bearing(geography, tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Bearing_point_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bearing(tgeogpoint, geography) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Bearing_tpoint_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION bearing(tgeogpoint, tgeogpoint) + -- RETURNS tfloat + -- AS 'MODULE_PATHNAME', 'Bearing_tpoint_tpoint' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION isSimple(tgeompoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Tpoint_is_simple' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION makeSimple(tgeompoint) + RETURNS tgeompoint[] + AS 'MODULE_PATHNAME', 'Tpoint_make_simple' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION atGeometry(tgeompoint, geometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_at_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusGeometry(tgeompoint, geometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_minus_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atStbox(tgeompoint, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_at_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atStbox(tgeogpoint, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tgeo_at_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusStbox(tgeompoint, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_minus_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusStbox(tgeogpoint, stbox, borderInc bool DEFAULT TRUE) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Tgeo_minus_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atElevation(tgeompoint, floatspan) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_at_elevation' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusElevation(tgeompoint, floatspan) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tgeo_minus_elevation' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tgeo_tile.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tgeo_tile.in.sql new file mode 100644 index 0000000..312f50f --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tgeo_tile.in.sql @@ -0,0 +1,141 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for spatial and spatiotemporal tiles + */ + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE FUNCTION spaceBoxes(tgeometry, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_space_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceBoxes(tgeometry, xsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceBoxes($1, $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceBoxes(tgeometry, xsize float, ysize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceBoxes($1, $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION timeBoxes(tgeometry, interval, + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION spaceTimeBoxes(tgeometry, xsize float, ysize float, + zsize float, interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_space_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceTimeBoxes(tgeometry, xsize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceTimeBoxes($1, $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceTimeBoxes(tgeometry, xsize float, ysize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceTimeBoxes($1, $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE TYPE point_tgeo AS ( + point geometry, + tgeo tgeometry +); + +CREATE FUNCTION spaceSplit(tgeometry, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tgeo + AS 'MODULE_PATHNAME', 'Tgeo_space_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceSplit(tgeometry, size float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tgeo + AS 'SELECT @extschema@.spaceSplit($1, $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceSplit(tgeometry, sizeX float, sizeY float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tgeo + AS 'SELECT @extschema@.spaceSplit($1, $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +CREATE TYPE point_time_tgeo AS ( + point geometry, + time timestamptz, + tgeo tgeometry +); + +CREATE FUNCTION spaceTimeSplit(tgeometry, xsize float, ysize float, + zsize float, interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tgeo + AS 'MODULE_PATHNAME', 'Tgeo_space_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceTimeSplit(tgeometry, size float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tgeo + AS 'SELECT @extschema@.spaceTimeSplit($1, $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION spaceTimeSplit(tgeometry, xsize float, ysize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tgeo + AS 'SELECT @extschema@.spaceTimeSplit($1, $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tpoint_tile.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tpoint_tile.in.sql new file mode 100644 index 0000000..733c95e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/058_tpoint_tile.in.sql @@ -0,0 +1,280 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for spatial and spatiotemporal tiles + */ + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE index_stbox AS ( + index integer, + tile stbox +); + +CREATE FUNCTION spaceTiles(bounds stbox, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderIinc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'MODULE_PATHNAME', 'Stbox_space_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTiles(bounds stbox, xsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTiles($1, $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTiles(bounds stbox, xsize float, ysize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTiles($1, $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timeTiles(bounds stbox, duration interval, + timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'MODULE_PATHNAME', 'Stbox_time_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spaceTimeTiles(bounds stbox, xsize float, ysize float, zsize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'MODULE_PATHNAME', 'Stbox_space_time_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeTiles(bounds stbox, xsize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTimeTiles($1, $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeTiles(bounds stbox, xsize float, ysize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTimeTiles($1, $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Convenience overloads taking a tgeompoint directly: derive the bounding + * stbox via the existing stbox(tgeompoint) cast and delegate to the + * stbox-typed overloads above. + ******************************************************************************/ + +CREATE FUNCTION spaceTiles(tgeompoint, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTiles(@extschema@.stbox($1), $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTiles(tgeompoint, xsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTiles(@extschema@.stbox($1), $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTiles(tgeompoint, xsize float, ysize float, + sorigin geometry DEFAULT 'Point(0 0 0)', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTiles(@extschema@.stbox($1), $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timeTiles(tgeompoint, duration interval, + torigin timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.timeTiles(@extschema@.stbox($1), $2, $3, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spaceTimeTiles(tgeompoint, xsize float, ysize float, + zsize float, duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTimeTiles(@extschema@.stbox($1), $2, $3, $4, $5, $6, $7, $8)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeTiles(tgeompoint, xsize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTimeTiles(@extschema@.stbox($1), $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeTiles(tgeompoint, xsize float, ysize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', borderInc boolean DEFAULT TRUE) + RETURNS SETOF index_stbox + AS 'SELECT @extschema@.spaceTimeTiles(@extschema@.stbox($1), $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION getSpaceTile(point geometry, xsize float, ysize float, + zsize float, sorigin geometry DEFAULT 'Point(0 0 0)') + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_get_space_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getSpaceTile(point geometry, xsize float, + sorigin geometry DEFAULT 'Point(0 0 0)') + RETURNS stbox + AS 'SELECT @extschema@.getSpaceTile($1, $2, $2, $2, $3)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getSpaceTile(point geometry, xsize float, ysize float, + sorigin geometry DEFAULT 'Point(0 0 0)') + RETURNS stbox + AS 'SELECT @extschema@.getSpaceTile($1, $2, $3, $2, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getStboxTimeTile(t timestamptz, duration interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_get_time_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getSpaceTimeTile(point geometry, t timestamptz, xsize float, + ysize float, zsize float, duration interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03') + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_get_space_time_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getSpaceTimeTile(point geometry, t timestamptz, xsize float, + duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03') + RETURNS stbox + AS 'SELECT @extschema@.getSpaceTimeTile($1, $2, $3, $3, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getSpaceTimeTile(point geometry, t timestamptz, xsize float, + ysize float, duration interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03') + RETURNS stbox + AS 'SELECT @extschema@.getSpaceTimeTile($1, $2, $3, $4, $3, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION spaceBoxes(tgeompoint, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_space_boxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceBoxes(tgeompoint, xsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceBoxes($1, $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceBoxes(tgeompoint, xsize float, ysize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceBoxes($1, $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timeBoxes(tgeompoint, interval, + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_time_boxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spaceTimeBoxes(tgeompoint, xsize float, ysize float, + zsize float, interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_space_time_boxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeBoxes(tgeompoint, xsize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceTimeBoxes($1, $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeBoxes(tgeompoint, xsize float, ysize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS stbox[] + AS 'SELECT @extschema@.spaceTimeBoxes($1, $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE TYPE point_tpoint AS ( + point geometry, + tpoint tgeompoint +); + +CREATE FUNCTION spaceSplit(tgeompoint, xsize float, ysize float, zsize float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tpoint + AS 'MODULE_PATHNAME', 'Tgeo_space_split' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceSplit(tgeompoint, size float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tpoint + AS 'SELECT @extschema@.spaceSplit($1, $2, $2, $2, $3, $4)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceSplit(tgeompoint, sizeX float, sizeY float, + sorigin geometry DEFAULT 'Point(0 0 0)', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_tpoint + AS 'SELECT @extschema@.spaceSplit($1, $2, $3, $2, $4, $5)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE point_time_tpoint AS ( + point geometry, + time timestamptz, + tpoint tgeompoint +); + +CREATE FUNCTION spaceTimeSplit(tgeompoint, xsize float, ysize float, + zsize float, interval, sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tpoint + AS 'MODULE_PATHNAME', 'Tgeo_space_time_split' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeSplit(tgeompoint, size float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tpoint + AS 'SELECT @extschema@.spaceTimeSplit($1, $2, $2, $2, $3, $4, $5, $6)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spaceTimeSplit(tgeompoint, xsize float, ysize float, interval, + sorigin geometry DEFAULT 'Point(0 0 0)', + torigin timestamptz DEFAULT '2000-01-03', bitmatrix boolean DEFAULT TRUE, + borderInc boolean DEFAULT TRUE) + RETURNS SETOF point_time_tpoint + AS 'SELECT @extschema@.spaceTimeSplit($1, $2, $3, $2, $4, $5, $6, $7)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tgeo_boxops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tgeo_boxops.in.sql new file mode 100644 index 0000000..1e32cc9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tgeo_boxops.in.sql @@ -0,0 +1,710 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal geometries/geographies + */ + +/***************************************************************************** + * Conversions + *****************************************************************************/ + +CREATE FUNCTION stbox(tgeometry) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(tgeography) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeometry AS stbox) WITH FUNCTION stbox(tgeometry); +CREATE CAST (tgeography AS stbox) WITH FUNCTION stbox(tgeography); + +/*****************************************************************************/ + +CREATE FUNCTION expandSpace(tgeometry, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION expandSpace(tgeography, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE FUNCTION spans(tgeometry) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tgeography) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxes(tgeometry) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stboxes(tgeography) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION splitNSpans(tgeometry, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tgeography, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNSpans(tgeometry, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tgeography, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNStboxes(tgeometry, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNStboxes(tgeography, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNStboxes(tgeometry, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNStboxes(tgeography, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tgeometry, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeometry, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tgeography, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeography, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tgeometry, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeometry, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tgeography, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeography, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tgeometry, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeometry, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tgeometry, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeometry, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tgeography, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeography, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tgeography, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeography, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tgeometry, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeometry, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tgeometry, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeometry, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tgeography, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeography, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tgeography, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeography, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tgeometry, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeometry, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tgeometry, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeometry, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tgeography, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeography, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tgeography, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeography, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tgeometry, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeometry, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tgeometry, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeometry, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tgeography, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeography, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tgeography, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeography, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tpoint_boxops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tpoint_boxops.in.sql new file mode 100644 index 0000000..6c689b3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/060_tpoint_boxops.in.sql @@ -0,0 +1,746 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal points + */ + +/***************************************************************************** + * Conversions + *****************************************************************************/ + +CREATE FUNCTION stbox(tgeompoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(tgeogpoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeompoint AS stbox) WITH FUNCTION stbox(tgeompoint); +CREATE CAST (tgeogpoint AS stbox) WITH FUNCTION stbox(tgeogpoint); + +/*****************************************************************************/ + +CREATE FUNCTION expandSpace(geometry, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION expandSpace(geography, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION expandSpace(tgeompoint, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION expandSpace(tgeogpoint, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE FUNCTION spans(tgeompoint) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tgeogpoint) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxes(tgeompoint) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stboxes(tgeogpoint) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stboxes(geometry) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stboxes(geography) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION splitNSpans(tgeompoint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tgeogpoint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNSpans(tgeompoint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tgeogpoint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNStboxes(tgeompoint, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNStboxes(tgeogpoint, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNStboxes(tgeompoint, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNStboxes(tgeogpoint, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Tgeo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNStboxes(geometry, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNStboxes(geography, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_split_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNStboxes(geometry, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNStboxes(geography, integer) + RETURNS stbox[] + AS 'MODULE_PATHNAME', 'Geo_split_each_n_stboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tgeompoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeompoint, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tgeogpoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeogpoint, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tgeompoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeompoint, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tgeogpoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeogpoint, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tgeompoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeompoint, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tgeogpoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeogpoint, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tgeompoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeompoint, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tgeogpoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeogpoint, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tgeompoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeompoint, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tgeogpoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeogpoint, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tgeo_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tgeo_posops.in.sql new file mode 100644 index 0000000..eeaee6d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tgeo_posops.in.sql @@ -0,0 +1,821 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for temporal geometries/geographies + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tgeometry */ + +CREATE FUNCTION temporal_before(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tstzspan op tgeography */ + +CREATE FUNCTION temporal_before(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tgeography, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tgeography, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tgeography, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tgeography, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_before(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tgeography, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tgeography, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tgeography, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tgeography, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tgeometry + *****************************************************************************/ + +/* tgeometry op tstzspan */ + +CREATE FUNCTION temporal_before(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeometry op stbox */ + +CREATE FUNCTION temporal_left(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeometry op tgeometry */ + +CREATE FUNCTION temporal_left(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(inst1 tgeometry, inst2 tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tgeography + *****************************************************************************/ + +/* tgeography op tstzspan */ + +CREATE FUNCTION temporal_before(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeography, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeography, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeography, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeography, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeography, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeography op stbox */ + +CREATE FUNCTION temporal_before(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeography, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeography, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeography, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeography, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeography, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeography op tgeography */ + +CREATE FUNCTION temporal_before(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tpoint_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tpoint_posops.in.sql new file mode 100644 index 0000000..9950042 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/062_tpoint_posops.in.sql @@ -0,0 +1,821 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for temporal geometry points. + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tgeompoint */ + +CREATE FUNCTION temporal_before(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tstzspan op tgeogpoint */ + +CREATE FUNCTION temporal_before(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_before(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tgeompoint + *****************************************************************************/ + +/* tgeompoint op tstzspan */ + +CREATE FUNCTION temporal_before(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeompoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeompoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeompoint op stbox */ + +CREATE FUNCTION temporal_left(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeompoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeompoint op tgeompoint */ + +CREATE FUNCTION temporal_left(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(inst1 tgeompoint, inst2 tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_below, + COMMUTATOR = |>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_above, + COMMUTATOR = <<|, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tgeogpoint + *****************************************************************************/ + +/* tgeogpoint op tstzspan */ + +CREATE FUNCTION temporal_before(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeogpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeogpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeogpoint op stbox */ + +CREATE FUNCTION temporal_before(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeogpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeogpoint, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeogpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeogpoint, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeogpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tgeogpoint op tgeogpoint */ + +CREATE FUNCTION temporal_before(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tgeo_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tgeo_distance.in.sql new file mode 100644 index 0000000..aaeb5ca --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tgeo_distance.in.sql @@ -0,0 +1,330 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal geometries/geographies + */ + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +CREATE FUNCTION tdistance(geometry, tgeometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeometry, geometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeometry, tgeometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geometry, RIGHTARG = tgeometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeometry, RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeometry, RIGHTARG = tgeometry, + COMMUTATOR = <-> +); + +/*****************************************************************************/ + +CREATE FUNCTION tdistance(geography, tgeography) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeography, geography) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeography, tgeography) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geography, RIGHTARG = tgeography, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeography, RIGHTARG = geography, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeography, RIGHTARG = tgeography, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant/distance and shortest line functions + *****************************************************************************/ + +CREATE FUNCTION nearestApproachInstant(geometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'NAI_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeometry, geometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'NAI_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'NAI_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachInstant(geography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'NAI_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeography, geography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'NAI_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'NAI_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachDistance(geometry, tgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeometry, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeometry, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeometry, tgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachDistance(geography, tgeography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeography, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tgeography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeography, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeography, tgeography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = tgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeometry, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeometry, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeometry, RIGHTARG = tgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +CREATE OPERATOR |=| ( + LEFTARG = geography, RIGHTARG = tgeography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeography, RIGHTARG = geography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tgeography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeography, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeography, RIGHTARG = tgeography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +CREATE FUNCTION shortestLine(geometry, tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeometry, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeometry, tgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shortestLine(geography, tgeography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeography, geography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeography, tgeography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Set-set spatial minimum distance + *****************************************************************************/ + +CREATE FUNCTION minDistance(tgeompoint[], tgeompoint[]) + RETURNS float + AS 'MODULE_PATHNAME', 'Tgeoarr_tgeoarr_mindist' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(tgeometry[], tgeometry[]) + RETURNS float + AS 'MODULE_PATHNAME', 'Tgeoarr_tgeoarr_mindist' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/* + * Scalar minDistance overloads where one side is a static geometry: + * spatial-min reduces to NAD (which is time-synchronous in general but + * is identical to spatial-min when one argument has no time dimension). + */ +CREATE FUNCTION minDistance(tgeompoint, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(geometry, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(tgeometry, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(geometry, tgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(tgeogpoint, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(geography, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(tgeography, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistance(geography, tgeography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/* + * 2-ary aggregate minDistance over pairs of temporal values. The + * scalar (tgeompoint, tgeompoint) form is replaced by this aggregate to + * keep the user-facing name unique (Solution 2 — no `Agg` suffix). On a + * one-row group the aggregate degenerates to the per-pair value, so any + * "scalar" use case is naturally covered. + */ +-- The function is not strict +CREATE FUNCTION minDistance_transfn(float, tgeompoint, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Mindistance_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION minDistance_transfn(float, tgeometry, tgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'Mindistance_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE minDistance(tgeompoint, tgeompoint) ( + SFUNC = minDistance_transfn, + STYPE = float, + COMBINEFUNC = float8smaller, + PARALLEL = SAFE +); +CREATE AGGREGATE minDistance(tgeometry, tgeometry) ( + SFUNC = minDistance_transfn, + STYPE = float, + COMBINEFUNC = float8smaller, + PARALLEL = SAFE +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tpoint_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tpoint_distance.in.sql new file mode 100644 index 0000000..6b48d03 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/064_tpoint_distance.in.sql @@ -0,0 +1,294 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal points + */ + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +CREATE FUNCTION tdistance(geometry(Point), tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeompoint, geometry(Point)) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeompoint, tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geometry, RIGHTARG = tgeompoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeompoint, RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + COMMUTATOR = <-> +); + +/*****************************************************************************/ + +CREATE FUNCTION tdistance(geography(Point), tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeogpoint, geography(Point)) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeogpoint, tgeogpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geography, RIGHTARG = tgeogpoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeogpoint, RIGHTARG = geography, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant/distance and shortest line functions + *****************************************************************************/ + +CREATE FUNCTION nearestApproachInstant(geometry, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'NAI_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeompoint, geometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'NAI_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'NAI_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachInstant(geography, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'NAI_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeogpoint, geography) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'NAI_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'NAI_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachDistance(geometry, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeompoint, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(geometry, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeompoint, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeompoint, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachDistance(geography, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeogpoint, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, geography) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(geography, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeogpoint, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeogpoint, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = tgeompoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeompoint, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tgeompoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeompoint, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeompoint, RIGHTARG = tgeompoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +CREATE OPERATOR |=| ( + LEFTARG = geography, RIGHTARG = tgeogpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeogpoint, RIGHTARG = geography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = geography, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = geography, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tgeogpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeogpoint, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeogpoint, RIGHTARG = tgeogpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +CREATE FUNCTION shortestLine(geometry, tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeompoint, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeompoint, tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shortestLine(geography, tgeogpoint) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeogpoint, geography) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeogpoint, tgeogpoint) + RETURNS geography + AS 'MODULE_PATHNAME', 'Shortestline_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/066_tpoint_similarity.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/066_tpoint_similarity.in.sql new file mode 100644 index 0000000..4bd4b7a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/066_tpoint_similarity.in.sql @@ -0,0 +1,88 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Similarity distance for temporal values. + * @note Currently, the discrete Hausdorff distance, the discrete Frechet + * distance and the Dynamic Time Warping (DTW) distance are implemented + */ + +CREATE FUNCTION frechetDistance(tgeompoint, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_frechet_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION frechetDistance(tgeogpoint, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_frechet_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION frechetDistancePath(tgeompoint, tgeompoint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_frechet_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION frechetDistancePath(tgeogpoint, tgeogpoint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_frechet_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION dynTimeWarpDistance(tgeompoint, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dynTimeWarpDistance(tgeogpoint, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dynTimeWarpPath(tgeompoint, tgeompoint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dynTimeWarpPath(tgeogpoint, tgeogpoint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION hausdorffDistance(tgeompoint, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_hausdorff_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION hausdorffDistance(tgeogpoint, tgeogpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_hausdorff_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tgeo_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tgeo_aggfuncs.in.sql new file mode 100644 index 0000000..72810a7 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tgeo_aggfuncs.in.sql @@ -0,0 +1,273 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal geometries/geographies + */ + +-- The function is not strict +CREATE FUNCTION tspatial_extent_transfn(stbox, tgeometry) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tspatial_extent_transfn(stbox, tgeography) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(tgeometry) ( + SFUNC = tspatial_extent_transfn, + STYPE = stbox, + COMBINEFUNC = stbox_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tgeography) ( + SFUNC = tspatial_extent_transfn, + STYPE = stbox, + COMBINEFUNC = stbox_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tgeometry) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tcount_transfn(internal, tgeography) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tgeometry) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tcount(tgeography) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, tgeometry, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wcount_transfn(internal, tgeography, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(tgeometry, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wcount(tgeography, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tgeometry) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_merge_transfn(internal, tgeography) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tgeometry_tagg_finalfn(internal) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography_tagg_finalfn(internal) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(tgeometry) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tgeometry_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); +CREATE AGGREGATE merge(tgeography) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tgeography_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeometry, tgeometry, + interp text DEFAULT NULL) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeography, tgeography, + interp text DEFAULT NULL) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeometry, tgeometry, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeography, tgeography, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_append_finalfn(tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tgeometry) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeography) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeography, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tgeometry, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeography, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeography, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tgeometry, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeography, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeography, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tgeometry, tgeometry) + RETURNS tgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tseq_transfn(tgeography, tgeography) + RETURNS tgeography + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tgeometry) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendSequence(tgeography) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tgeography, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tpoint_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tpoint_aggfuncs.in.sql new file mode 100644 index 0000000..6a0f1f2 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/068_tpoint_aggfuncs.in.sql @@ -0,0 +1,297 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal points + */ + +-- The function is not strict +CREATE FUNCTION tspatial_extent_transfn(stbox, tgeompoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tspatial_extent_transfn(stbox, tgeogpoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(tgeompoint) ( + SFUNC = tspatial_extent_transfn, + STYPE = stbox, + COMBINEFUNC = stbox_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tgeogpoint) ( + SFUNC = tspatial_extent_transfn, + STYPE = stbox, + COMBINEFUNC = stbox_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tgeompoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tcount_transfn(internal, tgeogpoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tgeompoint) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tcount(tgeogpoint) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, tgeompoint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wcount_transfn(internal, tgeogpoint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(tgeompoint, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wcount(tgeogpoint, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION tcentroid_transfn(internal, tgeompoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tpoint_tcentroid_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcentroid_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tpoint_tcentroid_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcentroid_finalfn(internal) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpoint_tcentroid_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE tcentroid(tgeompoint) ( + SFUNC = tcentroid_transfn, + STYPE = internal, + COMBINEFUNC = tcentroid_combinefn, + FINALFUNC = tcentroid_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tgeompoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_merge_transfn(internal, tgeogpoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tgeompoint_tagg_finalfn(internal) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint_tagg_finalfn(internal) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(tgeompoint) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tgeompoint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); +CREATE AGGREGATE merge(tgeogpoint) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tgeogpoint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeompoint, tgeompoint, + interp text DEFAULT NULL) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeogpoint, tgeogpoint, + interp text DEFAULT NULL) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tgeompoint, tgeompoint, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tgeogpoint, tgeogpoint, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_append_finalfn(tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tgeompoint) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeompoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeogpoint) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeogpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tgeompoint, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeompoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeogpoint, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeogpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tgeompoint, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeompoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tgeogpoint, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tgeogpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tgeompoint, tgeompoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tseq_transfn(tgeogpoint, tgeogpoint) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tgeompoint) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tgeompoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendSequence(tgeogpoint) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tgeogpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tgeo_spatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tgeo_spatialrels.in.sql new file mode 100644 index 0000000..5087a30 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tgeo_spatialrels.in.sql @@ -0,0 +1,411 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial relationships for temporal geometries/geographies + * @note Index support for these functions is enabled + */ + +/***************************************************************************** + * eContains, aContains + *****************************************************************************/ + +CREATE FUNCTION eContains(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eContains(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eContains(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aContains(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aContains(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aContains(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eCovers, aCovers + *****************************************************************************/ + +CREATE FUNCTION eCovers(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eCovers(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eCovers(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ecovers_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aCovers(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aCovers(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aCovers(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acovers_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDisjoint, aDisjoint + *****************************************************************************/ + +-- TODO implement the index support in the tspatial_supportfn + +CREATE FUNCTION _edisjoint(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(geometry, tgeometry) + RETURNS boolean + AS 'SELECT NOT(stbox($1) OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(tgeometry, geometry) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) stbox($2)) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(tgeometry, tgeometry) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +-- CREATE FUNCTION eDisjoint(geometry, tgeometry) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeometry, geometry) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeometry, tgeometry) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- TODO implement the index support in the tspatial_supportfn + +CREATE FUNCTION _edisjoint(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(geography, tgeography) + RETURNS boolean + AS 'SELECT NOT(stbox($1) OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(tgeography, geography) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) stbox($2)) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(tgeography, tgeography) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +-- CREATE FUNCTION eDisjoint(geography, tgeography) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeography, geography) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeography, tgeography) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aDisjoint(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDisjoint(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eIntersects, aIntersects + *****************************************************************************/ + +CREATE FUNCTION eIntersects(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eIntersects(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aIntersects(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aIntersects(geography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeography, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeography, tgeography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eTouches, aTouches + *****************************************************************************/ + +CREATE FUNCTION eTouches(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eTouches(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eTouches(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aTouches(geometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aTouches(tgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aTouches(tgeometry, tgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDwithin, aDwithin + *****************************************************************************/ + +CREATE FUNCTION eDwithin(geometry, tgeometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeometry, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeometry, tgeometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDwithin(geography, tgeography, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeography, geography, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeography, tgeography, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- NOTE: aDWithin for geograhies is not provided since it is based on the +-- PostGIS ST_Buffer() function which is performed by GEOS + +CREATE FUNCTION aDwithin(geometry, tgeometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tgeometry, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tgeometry, tgeometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDwithin(tgeography, tgeography, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tpoint_spatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tpoint_spatialrels.in.sql new file mode 100644 index 0000000..9130df7 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/070_tpoint_spatialrels.in.sql @@ -0,0 +1,341 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial relationships for temporal points + * @note Index support for these functions is enabled + */ + +/***************************************************************************** + * eContains, aContains + *****************************************************************************/ + +CREATE FUNCTION eContains(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Econtains_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aContains(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Acontains_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDisjoint, aDisjoint + *****************************************************************************/ + +-- TODO implement the index support in the tspatial_supportfn + +CREATE FUNCTION _edisjoint(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(geometry, tgeompoint) + RETURNS boolean + AS 'SELECT NOT(stbox($1) OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(tgeompoint, geometry) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) stbox($2)) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION edisjoint(tgeompoint, tgeompoint) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +-- CREATE FUNCTION eDisjoint(geometry, tgeompoint) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeompoint, geometry) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeompoint, tgeompoint) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(geography, tgeogpoint) + RETURNS boolean + AS 'SELECT NOT(stbox($1) OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(tgeogpoint, geography) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) stbox($2)) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION _edisjoint(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDisjoint(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'SELECT NOT($1 OPERATOR(@extschema@.&&) $2) OR @extschema@._edisjoint($1,$2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +-- CREATE FUNCTION eDisjoint(geography, tgeogpoint) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_geo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeogpoint, geography) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_geo' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- CREATE FUNCTION eDisjoint(tgeogpoint, tgeogpoint) + -- RETURNS boolean + -- AS 'MODULE_PATHNAME', 'Edisjoint_tgeo_tgeo' + -- SUPPORT tspatial_supportfn + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- TODO implement the index support in the tspatial_supportfn + +CREATE FUNCTION aDisjoint(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDisjoint(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDisjoint(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adisjoint_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eIntersects, aIntersects + *****************************************************************************/ + +CREATE FUNCTION eIntersects(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eIntersects(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eIntersects(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Eintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aIntersects(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeompoint, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aIntersects(geography, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeogpoint, geography) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aIntersects(tgeogpoint, tgeogpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Aintersects_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eTouches, aTouches + *****************************************************************************/ + +CREATE FUNCTION eTouches(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_geo_tpoint' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eTouches(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Etouches_tpoint_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION aTouches(geometry, tgeompoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_geo_tpoint' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aTouches(tgeompoint, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Atouches_tpoint_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * eDwithin, aDwithin + *****************************************************************************/ + +CREATE FUNCTION eDwithin(geometry, tgeompoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeompoint, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeompoint, tgeompoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION eDwithin(geography, tgeogpoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeogpoint, geography, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION eDwithin(tgeogpoint, tgeogpoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Edwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- NOTE: aDWithin for geograhies is not provided since it is based on the +-- PostGIS ST_Buffer() function which is performed by GEOS + +CREATE FUNCTION aDwithin(geometry, tgeompoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_geo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tgeompoint, geometry, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION aDwithin(tgeompoint, tgeompoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION aDwithin(tgeogpoint, tgeogpoint, dist float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adwithin_tgeo_tgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tgeo_tempspatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tgeo_tempspatialrels.in.sql new file mode 100644 index 0000000..654387a --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tgeo_tempspatialrels.in.sql @@ -0,0 +1,148 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal spatial relationships for temporal geometries/geographies + */ + +/***************************************************************************** + * tContains + *****************************************************************************/ + +CREATE FUNCTION tContains(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tContains(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tCovers + *****************************************************************************/ + +CREATE FUNCTION tCovers(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tCovers(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcovers_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDisjoint + *****************************************************************************/ + +CREATE FUNCTION tDisjoint(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- Alias for temporal not equals, that is, geo_tne or #<> +CREATE FUNCTION tDisjoint(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tgeography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tIntersects + *****************************************************************************/ + +CREATE FUNCTION tIntersects(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- Alias for temporal equals, that is, tgeo_teq or #= +CREATE FUNCTION tIntersects(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tgeography, tgeography) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tTouches + *****************************************************************************/ + +CREATE FUNCTION tTouches(geometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tgeometry, tgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDwithin + *****************************************************************************/ + +CREATE FUNCTION tDwithin(geometry, tgeometry, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tDwithin(tgeometry, geometry, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tgeo_geo' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tDwithin(tgeometry, tgeometry, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tpoint_tempspatialrels.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tpoint_tempspatialrels.in.sql new file mode 100644 index 0000000..5b1fee6 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/072_tpoint_tempspatialrels.in.sql @@ -0,0 +1,118 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal spatial relationships for temporal geometries/geographies + */ + +/***************************************************************************** + * tContains + *****************************************************************************/ + +CREATE FUNCTION tContains(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tcontains_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDisjoint + *****************************************************************************/ + +CREATE FUNCTION tDisjoint(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tgeompoint, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- Alias for temporal not equals, that is, tgeo_tne or #<> +CREATE FUNCTION tDisjoint(tgeompoint, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDisjoint(tgeogpoint, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdisjoint_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tIntersects + *****************************************************************************/ + +CREATE FUNCTION tIntersects(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tgeompoint, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- Alias for temporal equals, that is, tgeo_teq or #= +CREATE FUNCTION tIntersects(tgeompoint, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tIntersects(tgeogpoint, tgeogpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tintersects_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tTouches + *****************************************************************************/ + +CREATE FUNCTION tTouches(geometry, tgeompoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tTouches(tgeompoint, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Ttouches_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * tDwithin + *****************************************************************************/ + +CREATE FUNCTION tDwithin(geometry, tgeompoint, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_geo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDwithin(tgeompoint, geometry, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDwithin(tgeompoint, tgeompoint, dist float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tdwithin_tgeo_tgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tgeo_gist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tgeo_gist.in.sql new file mode 100644 index 0000000..b00ed50 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tgeo_gist.in.sql @@ -0,0 +1,211 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST index for temporal geometries/geographies + */ + +/******************************************************************************/ + +CREATE FUNCTION tgeometry_gist_consistent(internal, tgeometry, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeography_gist_consistent(internal, tgeography, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox_gist_union(internal, internal) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Stbox_gist_union' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_gist_penalty(internal, internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Stbox_gist_penalty' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_gist_picksplit(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Stbox_gist_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_gist_same(stbox, stbox, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Stbox_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_gist_distance(internal, stbox, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Stbox_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tspatial_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tspatial_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeometry_rtree_ops + DEFAULT FOR TYPE tgeometry USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (tgeometry, stbox), + OPERATOR 1 << (tgeometry, tgeometry), + -- overlaps or left + OPERATOR 2 &< (tgeometry, stbox), + OPERATOR 2 &< (tgeometry, tgeometry), + -- overlaps + OPERATOR 3 && (tgeometry, tstzspan), + OPERATOR 3 && (tgeometry, stbox), + OPERATOR 3 && (tgeometry, tgeometry), + -- overlaps or right + OPERATOR 4 &> (tgeometry, stbox), + OPERATOR 4 &> (tgeometry, tgeometry), + -- strictly right + OPERATOR 5 >> (tgeometry, stbox), + OPERATOR 5 >> (tgeometry, tgeometry), + -- same + OPERATOR 6 ~= (tgeometry, tstzspan), + OPERATOR 6 ~= (tgeometry, stbox), + OPERATOR 6 ~= (tgeometry, tgeometry), + -- contains + OPERATOR 7 @> (tgeometry, tstzspan), + OPERATOR 7 @> (tgeometry, stbox), + OPERATOR 7 @> (tgeometry, tgeometry), + -- contained by + OPERATOR 8 <@ (tgeometry, tstzspan), + OPERATOR 8 <@ (tgeometry, stbox), + OPERATOR 8 <@ (tgeometry, tgeometry), + -- overlaps or below + OPERATOR 9 &<| (tgeometry, stbox), + OPERATOR 9 &<| (tgeometry, tgeometry), + -- strictly below + OPERATOR 10 <<| (tgeometry, stbox), + OPERATOR 10 <<| (tgeometry, tgeometry), + -- strictly above + OPERATOR 11 |>> (tgeometry, stbox), + OPERATOR 11 |>> (tgeometry, tgeometry), + -- overlaps or above + OPERATOR 12 |&> (tgeometry, stbox), + OPERATOR 12 |&> (tgeometry, tgeometry), + -- adjacent + OPERATOR 17 -|- (tgeometry, tstzspan), + OPERATOR 17 -|- (tgeometry, stbox), + OPERATOR 17 -|- (tgeometry, tgeometry), + -- nearest approach distance + OPERATOR 25 |=| (tgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeometry, tgeometry) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeometry, tstzspan), + OPERATOR 28 &<# (tgeometry, stbox), + OPERATOR 28 &<# (tgeometry, tgeometry), + -- strictly before + OPERATOR 29 <<# (tgeometry, tstzspan), + OPERATOR 29 <<# (tgeometry, stbox), + OPERATOR 29 <<# (tgeometry, tgeometry), + -- strictly after + OPERATOR 30 #>> (tgeometry, tstzspan), + OPERATOR 30 #>> (tgeometry, stbox), + OPERATOR 30 #>> (tgeometry, tgeometry), + -- overlaps or after + OPERATOR 31 #&> (tgeometry, tstzspan), + OPERATOR 31 #&> (tgeometry, stbox), + OPERATOR 31 #&> (tgeometry, tgeometry), + -- overlaps or front + OPERATOR 32 &> (tgeometry, stbox), + OPERATOR 34 />> (tgeometry, tgeometry), + -- overlaps or back + OPERATOR 35 /&> (tgeometry, stbox), + OPERATOR 35 /&> (tgeometry, tgeometry), + -- functions + FUNCTION 1 tgeometry_gist_consistent(internal, tgeometry, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal), + FUNCTION 8 stbox_gist_distance(internal, stbox, smallint, oid, internal); + +CREATE OPERATOR CLASS tgeography_rtree_ops + DEFAULT FOR TYPE tgeography USING gist AS + STORAGE stbox, + -- overlaps + OPERATOR 3 && (tgeography, tstzspan), + OPERATOR 3 && (tgeography, stbox), + OPERATOR 3 && (tgeography, tgeography), + -- same + OPERATOR 6 ~= (tgeography, tstzspan), + OPERATOR 6 ~= (tgeography, stbox), + OPERATOR 6 ~= (tgeography, tgeography), + -- contains + OPERATOR 7 @> (tgeography, tstzspan), + OPERATOR 7 @> (tgeography, stbox), + OPERATOR 7 @> (tgeography, tgeography), + -- contained by + OPERATOR 8 <@ (tgeography, tstzspan), + OPERATOR 8 <@ (tgeography, stbox), + OPERATOR 8 <@ (tgeography, tgeography), + -- adjacent + OPERATOR 17 -|- (tgeography, tstzspan), + OPERATOR 17 -|- (tgeography, stbox), + OPERATOR 17 -|- (tgeography, tgeography), + -- distance + OPERATOR 25 |=| (tgeography, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeography, tgeography) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeography, tstzspan), + OPERATOR 28 &<# (tgeography, stbox), + OPERATOR 28 &<# (tgeography, tgeography), + -- strictly before + OPERATOR 29 <<# (tgeography, tstzspan), + OPERATOR 29 <<# (tgeography, stbox), + OPERATOR 29 <<# (tgeography, tgeography), + -- strictly after + OPERATOR 30 #>> (tgeography, tstzspan), + OPERATOR 30 #>> (tgeography, stbox), + OPERATOR 30 #>> (tgeography, tgeography), + -- overlaps or after + OPERATOR 31 #&> (tgeography, tstzspan), + OPERATOR 31 #&> (tgeography, stbox), + OPERATOR 31 #&> (tgeography, tgeography), + -- functions + FUNCTION 1 tgeography_gist_consistent(internal, tgeography, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal), + FUNCTION 8 stbox_gist_distance(internal, stbox, smallint, oid, internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tpoint_gist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tpoint_gist.in.sql new file mode 100644 index 0000000..6b6a6a0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/073_tpoint_gist.in.sql @@ -0,0 +1,276 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST index for temporal points + */ + +CREATE FUNCTION stbox_gist_consistent(internal, stbox, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS stbox_rtree_ops + DEFAULT FOR TYPE stbox USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (stbox, stbox), + OPERATOR 1 << (stbox, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (stbox, stbox), + OPERATOR 2 &< (stbox, tgeompoint), + -- overlaps + OPERATOR 3 && (stbox, stbox), + OPERATOR 3 && (stbox, tgeompoint), + OPERATOR 3 && (stbox, tgeogpoint), + -- overlaps or right + OPERATOR 4 &> (stbox, stbox), + OPERATOR 4 &> (stbox, tgeompoint), + -- strictly right + OPERATOR 5 >> (stbox, stbox), + OPERATOR 5 >> (stbox, tgeompoint), + -- same + OPERATOR 6 ~= (stbox, stbox), + OPERATOR 6 ~= (stbox, tgeompoint), + OPERATOR 6 ~= (stbox, tgeogpoint), + -- contains + OPERATOR 7 @> (stbox, stbox), + OPERATOR 7 @> (stbox, tgeompoint), + OPERATOR 7 @> (stbox, tgeogpoint), + -- contained by + OPERATOR 8 <@ (stbox, stbox), + OPERATOR 8 <@ (stbox, tgeompoint), + OPERATOR 8 <@ (stbox, tgeogpoint), + -- overlaps or below + OPERATOR 9 &<| (stbox, stbox), + OPERATOR 9 &<| (stbox, tgeompoint), + -- strictly below + OPERATOR 10 <<| (stbox, stbox), + OPERATOR 10 <<| (stbox, tgeompoint), + -- strictly above + OPERATOR 11 |>> (stbox, stbox), + OPERATOR 11 |>> (stbox, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (stbox, stbox), + OPERATOR 12 |&> (stbox, tgeompoint), + -- adjacent + OPERATOR 17 -|- (stbox, stbox), + OPERATOR 17 -|- (stbox, tgeompoint), + OPERATOR 17 -|- (stbox, tgeogpoint), + -- nearest approach distance + OPERATOR 25 |=| (stbox, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (stbox, tgeompoint) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (stbox, tgeogpoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (stbox, stbox), + OPERATOR 28 &<# (stbox, tgeompoint), + OPERATOR 28 &<# (stbox, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (stbox, stbox), + OPERATOR 29 <<# (stbox, tgeompoint), + OPERATOR 29 <<# (stbox, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (stbox, stbox), + OPERATOR 30 #>> (stbox, tgeompoint), + OPERATOR 30 #>> (stbox, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (stbox, stbox), + OPERATOR 31 #&> (stbox, tgeompoint), + OPERATOR 31 #&> (stbox, tgeogpoint), + -- overlaps or front + OPERATOR 32 &> (stbox, stbox), + OPERATOR 34 />> (stbox, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (stbox, stbox), + OPERATOR 35 /&> (stbox, tgeompoint), + -- functions + FUNCTION 1 stbox_gist_consistent(internal, stbox, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal), + FUNCTION 8 stbox_gist_distance(internal, stbox, smallint, oid, internal); + +/******************************************************************************/ + +CREATE FUNCTION tgeompoint_gist_consistent(internal, tgeompoint, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeogpoint_gist_consistent(internal, tgeogpoint, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tgeompoint_rtree_ops + DEFAULT FOR TYPE tgeompoint USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (tgeompoint, stbox), + OPERATOR 1 << (tgeompoint, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (tgeompoint, stbox), + OPERATOR 2 &< (tgeompoint, tgeompoint), + -- overlaps + OPERATOR 3 && (tgeompoint, tstzspan), + OPERATOR 3 && (tgeompoint, stbox), + OPERATOR 3 && (tgeompoint, tgeompoint), + -- overlaps or right + OPERATOR 4 &> (tgeompoint, stbox), + OPERATOR 4 &> (tgeompoint, tgeompoint), + -- strictly right + OPERATOR 5 >> (tgeompoint, stbox), + OPERATOR 5 >> (tgeompoint, tgeompoint), + -- same + OPERATOR 6 ~= (tgeompoint, tstzspan), + OPERATOR 6 ~= (tgeompoint, stbox), + OPERATOR 6 ~= (tgeompoint, tgeompoint), + -- contains + OPERATOR 7 @> (tgeompoint, tstzspan), + OPERATOR 7 @> (tgeompoint, stbox), + OPERATOR 7 @> (tgeompoint, tgeompoint), + -- contained by + OPERATOR 8 <@ (tgeompoint, tstzspan), + OPERATOR 8 <@ (tgeompoint, stbox), + OPERATOR 8 <@ (tgeompoint, tgeompoint), + -- overlaps or below + OPERATOR 9 &<| (tgeompoint, stbox), + OPERATOR 9 &<| (tgeompoint, tgeompoint), + -- strictly below + OPERATOR 10 <<| (tgeompoint, stbox), + OPERATOR 10 <<| (tgeompoint, tgeompoint), + -- strictly above + OPERATOR 11 |>> (tgeompoint, stbox), + OPERATOR 11 |>> (tgeompoint, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (tgeompoint, stbox), + OPERATOR 12 |&> (tgeompoint, tgeompoint), + -- adjacent + OPERATOR 17 -|- (tgeompoint, tstzspan), + OPERATOR 17 -|- (tgeompoint, stbox), + OPERATOR 17 -|- (tgeompoint, tgeompoint), + -- nearest approach distance + OPERATOR 25 |=| (tgeompoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeompoint, tgeompoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeompoint, tstzspan), + OPERATOR 28 &<# (tgeompoint, stbox), + OPERATOR 28 &<# (tgeompoint, tgeompoint), + -- strictly before + OPERATOR 29 <<# (tgeompoint, tstzspan), + OPERATOR 29 <<# (tgeompoint, stbox), + OPERATOR 29 <<# (tgeompoint, tgeompoint), + -- strictly after + OPERATOR 30 #>> (tgeompoint, tstzspan), + OPERATOR 30 #>> (tgeompoint, stbox), + OPERATOR 30 #>> (tgeompoint, tgeompoint), + -- overlaps or after + OPERATOR 31 #&> (tgeompoint, tstzspan), + OPERATOR 31 #&> (tgeompoint, stbox), + OPERATOR 31 #&> (tgeompoint, tgeompoint), + -- overlaps or front + OPERATOR 32 &> (tgeompoint, stbox), + OPERATOR 34 />> (tgeompoint, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (tgeompoint, stbox), + OPERATOR 35 /&> (tgeompoint, tgeompoint), + -- functions + FUNCTION 1 tgeompoint_gist_consistent(internal, tgeompoint, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal), + FUNCTION 8 stbox_gist_distance(internal, stbox, smallint, oid, internal); + +CREATE OPERATOR CLASS tgeogpoint_rtree_ops + DEFAULT FOR TYPE tgeogpoint USING gist AS + STORAGE stbox, + -- overlaps + OPERATOR 3 && (tgeogpoint, tstzspan), + OPERATOR 3 && (tgeogpoint, stbox), + OPERATOR 3 && (tgeogpoint, tgeogpoint), + -- same + OPERATOR 6 ~= (tgeogpoint, tstzspan), + OPERATOR 6 ~= (tgeogpoint, stbox), + OPERATOR 6 ~= (tgeogpoint, tgeogpoint), + -- contains + OPERATOR 7 @> (tgeogpoint, tstzspan), + OPERATOR 7 @> (tgeogpoint, stbox), + OPERATOR 7 @> (tgeogpoint, tgeogpoint), + -- contained by + OPERATOR 8 <@ (tgeogpoint, tstzspan), + OPERATOR 8 <@ (tgeogpoint, stbox), + OPERATOR 8 <@ (tgeogpoint, tgeogpoint), + -- adjacent + OPERATOR 17 -|- (tgeogpoint, tstzspan), + OPERATOR 17 -|- (tgeogpoint, stbox), + OPERATOR 17 -|- (tgeogpoint, tgeogpoint), + -- distance + OPERATOR 25 |=| (tgeogpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeogpoint, tgeogpoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeogpoint, tstzspan), + OPERATOR 28 &<# (tgeogpoint, stbox), + OPERATOR 28 &<# (tgeogpoint, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (tgeogpoint, tstzspan), + OPERATOR 29 <<# (tgeogpoint, stbox), + OPERATOR 29 <<# (tgeogpoint, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (tgeogpoint, tstzspan), + OPERATOR 30 #>> (tgeogpoint, stbox), + OPERATOR 30 #>> (tgeogpoint, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (tgeogpoint, tstzspan), + OPERATOR 31 #&> (tgeogpoint, stbox), + OPERATOR 31 #&> (tgeogpoint, tgeogpoint), + -- functions + FUNCTION 1 tgeogpoint_gist_consistent(internal, tgeogpoint, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal), + FUNCTION 8 stbox_gist_distance(internal, stbox, smallint, oid, internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tgeo_spgist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tgeo_spgist.in.sql new file mode 100644 index 0000000..b8626fc --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tgeo_spgist.in.sql @@ -0,0 +1,352 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Quad-tree and k-d tree SP-GiST index for temporal + * geometries/geographies + */ + +CREATE FUNCTION stbox_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_quadtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_quadtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_quadtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_quadtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_quadtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_quadtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_spgist_leaf_consistent(internal, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_spgist_leaf_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tspatial_spgist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tspatial_spgist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeometry_quadtree_ops + DEFAULT FOR TYPE tgeometry USING spgist AS + -- strictly left + OPERATOR 1 << (tgeometry, stbox), + OPERATOR 1 << (tgeometry, tgeometry), + -- overlaps or left + OPERATOR 2 &< (tgeometry, stbox), + OPERATOR 2 &< (tgeometry, tgeometry), + -- overlaps + OPERATOR 3 && (tgeometry, tstzspan), + OPERATOR 3 && (tgeometry, stbox), + OPERATOR 3 && (tgeometry, tgeometry), + -- overlaps or right + OPERATOR 4 &> (tgeometry, stbox), + OPERATOR 4 &> (tgeometry, tgeometry), + -- strictly right + OPERATOR 5 >> (tgeometry, stbox), + OPERATOR 5 >> (tgeometry, tgeometry), + -- same + OPERATOR 6 ~= (tgeometry, tstzspan), + OPERATOR 6 ~= (tgeometry, stbox), + OPERATOR 6 ~= (tgeometry, tgeometry), + -- contains + OPERATOR 7 @> (tgeometry, tstzspan), + OPERATOR 7 @> (tgeometry, stbox), + OPERATOR 7 @> (tgeometry, tgeometry), + -- contained by + OPERATOR 8 <@ (tgeometry, tstzspan), + OPERATOR 8 <@ (tgeometry, stbox), + OPERATOR 8 <@ (tgeometry, tgeometry), + -- overlaps or below + OPERATOR 9 &<| (tgeometry, stbox), + OPERATOR 9 &<| (tgeometry, tgeometry), + -- strictly below + OPERATOR 10 <<| (tgeometry, stbox), + OPERATOR 10 <<| (tgeometry, tgeometry), + -- strictly above + OPERATOR 11 |>> (tgeometry, stbox), + OPERATOR 11 |>> (tgeometry, tgeometry), + -- overlaps or above + OPERATOR 12 |&> (tgeometry, stbox), + OPERATOR 12 |&> (tgeometry, tgeometry), + -- adjacent + OPERATOR 17 -|- (tgeometry, tstzspan), + OPERATOR 17 -|- (tgeometry, stbox), + OPERATOR 17 -|- (tgeometry, tgeometry), + -- nearest approach distance + OPERATOR 25 |=| (tgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeometry, tgeometry) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeometry, tstzspan), + OPERATOR 28 &<# (tgeometry, stbox), + OPERATOR 28 &<# (tgeometry, tgeometry), + -- strictly before + OPERATOR 29 <<# (tgeometry, tstzspan), + OPERATOR 29 <<# (tgeometry, stbox), + OPERATOR 29 <<# (tgeometry, tgeometry), + -- strictly after + OPERATOR 30 #>> (tgeometry, tstzspan), + OPERATOR 30 #>> (tgeometry, stbox), + OPERATOR 30 #>> (tgeometry, tgeometry), + -- overlaps or after + OPERATOR 31 #&> (tgeometry, tstzspan), + OPERATOR 31 #&> (tgeometry, stbox), + OPERATOR 31 #&> (tgeometry, tgeometry), + -- overlaps or front + OPERATOR 32 &> (tgeometry, stbox), + OPERATOR 34 />> (tgeometry, tgeometry), + -- overlaps or back + OPERATOR 35 /&> (tgeometry, stbox), + OPERATOR 35 /&> (tgeometry, tgeometry), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE FUNCTION stbox_kdtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_kdtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_kdtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_kdtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox_kdtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Stbox_kdtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeometry_kdtree_ops + FOR TYPE tgeometry USING spgist AS + -- strictly left + OPERATOR 1 << (tgeometry, stbox), + OPERATOR 1 << (tgeometry, tgeometry), + -- overlaps or left + OPERATOR 2 &< (tgeometry, stbox), + OPERATOR 2 &< (tgeometry, tgeometry), + -- overlaps + OPERATOR 3 && (tgeometry, tstzspan), + OPERATOR 3 && (tgeometry, stbox), + OPERATOR 3 && (tgeometry, tgeometry), + -- overlaps or right + OPERATOR 4 &> (tgeometry, stbox), + OPERATOR 4 &> (tgeometry, tgeometry), + -- strictly right + OPERATOR 5 >> (tgeometry, stbox), + OPERATOR 5 >> (tgeometry, tgeometry), + -- same + OPERATOR 6 ~= (tgeometry, tstzspan), + OPERATOR 6 ~= (tgeometry, stbox), + OPERATOR 6 ~= (tgeometry, tgeometry), + -- contains + OPERATOR 7 @> (tgeometry, tstzspan), + OPERATOR 7 @> (tgeometry, stbox), + OPERATOR 7 @> (tgeometry, tgeometry), + -- contained by + OPERATOR 8 <@ (tgeometry, tstzspan), + OPERATOR 8 <@ (tgeometry, stbox), + OPERATOR 8 <@ (tgeometry, tgeometry), + -- overlaps or below + OPERATOR 9 &<| (tgeometry, stbox), + OPERATOR 9 &<| (tgeometry, tgeometry), + -- strictly below + OPERATOR 10 <<| (tgeometry, stbox), + OPERATOR 10 <<| (tgeometry, tgeometry), + -- strictly above + OPERATOR 11 |>> (tgeometry, stbox), + OPERATOR 11 |>> (tgeometry, tgeometry), + -- overlaps or above + OPERATOR 12 |&> (tgeometry, stbox), + OPERATOR 12 |&> (tgeometry, tgeometry), + -- adjacent + OPERATOR 17 -|- (tgeometry, tstzspan), + OPERATOR 17 -|- (tgeometry, stbox), + OPERATOR 17 -|- (tgeometry, tgeometry), + -- nearest approach distance + OPERATOR 25 |=| (tgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeometry, tgeometry) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeometry, tstzspan), + OPERATOR 28 &<# (tgeometry, stbox), + OPERATOR 28 &<# (tgeometry, tgeometry), + -- strictly before + OPERATOR 29 <<# (tgeometry, tstzspan), + OPERATOR 29 <<# (tgeometry, stbox), + OPERATOR 29 <<# (tgeometry, tgeometry), + -- strictly after + OPERATOR 30 #>> (tgeometry, tstzspan), + OPERATOR 30 #>> (tgeometry, stbox), + OPERATOR 30 #>> (tgeometry, tgeometry), + -- overlaps or after + OPERATOR 31 #&> (tgeometry, tstzspan), + OPERATOR 31 #&> (tgeometry, stbox), + OPERATOR 31 #&> (tgeometry, tgeometry), + -- overlaps or front + OPERATOR 32 &> (tgeometry, stbox), + OPERATOR 34 />> (tgeometry, tgeometry), + -- overlaps or back + OPERATOR 35 /&> (tgeometry, stbox), + OPERATOR 35 /&> (tgeometry, tgeometry), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeography_quadtree_ops + DEFAULT FOR TYPE tgeography USING spgist AS + -- overlaps + OPERATOR 3 && (tgeography, tstzspan), + OPERATOR 3 && (tgeography, stbox), + OPERATOR 3 && (tgeography, tgeography), + -- same + OPERATOR 6 ~= (tgeography, tstzspan), + OPERATOR 6 ~= (tgeography, stbox), + OPERATOR 6 ~= (tgeography, tgeography), + -- contains + OPERATOR 7 @> (tgeography, tstzspan), + OPERATOR 7 @> (tgeography, stbox), + OPERATOR 7 @> (tgeography, tgeography), + -- contained by + OPERATOR 8 <@ (tgeography, tstzspan), + OPERATOR 8 <@ (tgeography, stbox), + OPERATOR 8 <@ (tgeography, tgeography), + -- adjacent + OPERATOR 17 -|- (tgeography, tstzspan), + OPERATOR 17 -|- (tgeography, stbox), + OPERATOR 17 -|- (tgeography, tgeography), + -- nearest approach distance + OPERATOR 25 |=| (tgeography, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeography, tgeography) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeography, tstzspan), + OPERATOR 28 &<# (tgeography, stbox), + OPERATOR 28 &<# (tgeography, tgeography), + -- strictly before + OPERATOR 29 <<# (tgeography, tstzspan), + OPERATOR 29 <<# (tgeography, stbox), + OPERATOR 29 <<# (tgeography, tgeography), + -- strictly after + OPERATOR 30 #>> (tgeography, tstzspan), + OPERATOR 30 #>> (tgeography, stbox), + OPERATOR 30 #>> (tgeography, tgeography), + -- overlaps or after + OPERATOR 31 #&> (tgeography, tstzspan), + OPERATOR 31 #&> (tgeography, stbox), + OPERATOR 31 #&> (tgeography, tgeography), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeography_kdtree_ops + FOR TYPE tgeography USING spgist AS + -- overlaps + OPERATOR 3 && (tgeography, tstzspan), + OPERATOR 3 && (tgeography, tgeography), + -- same + OPERATOR 6 ~= (tgeography, tstzspan), + OPERATOR 6 ~= (tgeography, stbox), + OPERATOR 6 ~= (tgeography, tgeography), + -- contains + OPERATOR 7 @> (tgeography, tstzspan), + OPERATOR 7 @> (tgeography, stbox), + OPERATOR 7 @> (tgeography, tgeography), + -- contained by + OPERATOR 8 <@ (tgeography, tstzspan), + OPERATOR 8 <@ (tgeography, stbox), + OPERATOR 8 <@ (tgeography, tgeography), + -- adjacent + OPERATOR 17 -|- (tgeography, tstzspan), + OPERATOR 17 -|- (tgeography, stbox), + OPERATOR 17 -|- (tgeography, tgeography), + -- nearest approach distance + OPERATOR 25 |=| (tgeography, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeography, tgeography) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeography, tstzspan), + OPERATOR 28 &<# (tgeography, stbox), + OPERATOR 28 &<# (tgeography, tgeography), + -- strictly before + OPERATOR 29 <<# (tgeography, tstzspan), + OPERATOR 29 <<# (tgeography, stbox), + OPERATOR 29 <<# (tgeography, tgeography), + -- strictly after + OPERATOR 30 #>> (tgeography, tstzspan), + OPERATOR 30 #>> (tgeography, stbox), + OPERATOR 30 #>> (tgeography, tgeography), + -- overlaps or after + OPERATOR 31 #&> (tgeography, tstzspan), + OPERATOR 31 #&> (tgeography, stbox), + OPERATOR 31 #&> (tgeography, tgeography), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tpoint_spgist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tpoint_spgist.in.sql new file mode 100644 index 0000000..980403d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/074_tpoint_spgist.in.sql @@ -0,0 +1,476 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Quad-tree and k-d tree SP-GiST index for temporal points + */ + +/******************************************************************************/ + +CREATE OPERATOR CLASS stbox_quadtree_ops + DEFAULT FOR TYPE stbox USING spgist AS + -- strictly left + OPERATOR 1 << (stbox, stbox), + OPERATOR 1 << (stbox, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (stbox, stbox), + OPERATOR 2 &< (stbox, tgeompoint), + -- overlaps + OPERATOR 3 && (stbox, stbox), + OPERATOR 3 && (stbox, tgeompoint), + OPERATOR 3 && (stbox, tgeogpoint), + -- overlaps or right + OPERATOR 4 &> (stbox, stbox), + OPERATOR 4 &> (stbox, tgeompoint), + -- strictly right + OPERATOR 5 >> (stbox, stbox), + OPERATOR 5 >> (stbox, tgeompoint), + -- same + OPERATOR 6 ~= (stbox, stbox), + OPERATOR 6 ~= (stbox, tgeompoint), + OPERATOR 6 ~= (stbox, tgeogpoint), + -- contains + OPERATOR 7 @> (stbox, stbox), + OPERATOR 7 @> (stbox, tgeompoint), + OPERATOR 7 @> (stbox, tgeogpoint), + -- contained by + OPERATOR 8 <@ (stbox, stbox), + OPERATOR 8 <@ (stbox, tgeompoint), + OPERATOR 8 <@ (stbox, tgeogpoint), + -- overlaps or below + OPERATOR 9 &<| (stbox, stbox), + OPERATOR 9 &<| (stbox, tgeompoint), + -- strictly below + OPERATOR 10 <<| (stbox, stbox), + OPERATOR 10 <<| (stbox, tgeompoint), + -- strictly above + OPERATOR 11 |>> (stbox, stbox), + OPERATOR 11 |>> (stbox, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (stbox, stbox), + OPERATOR 12 |&> (stbox, tgeompoint), + -- adjacent + OPERATOR 17 -|- (stbox, stbox), + OPERATOR 17 -|- (stbox, tgeompoint), + OPERATOR 17 -|- (stbox, tgeogpoint), + -- overlaps or before + OPERATOR 28 &<# (stbox, stbox), + OPERATOR 28 &<# (stbox, tgeompoint), + OPERATOR 28 &<# (stbox, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (stbox, stbox), + OPERATOR 29 <<# (stbox, tgeompoint), + OPERATOR 29 <<# (stbox, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (stbox, stbox), + OPERATOR 30 #>> (stbox, tgeompoint), + OPERATOR 30 #>> (stbox, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (stbox, stbox), + OPERATOR 31 #&> (stbox, tgeompoint), + OPERATOR 31 #&> (stbox, tgeogpoint), + -- overlaps or front + OPERATOR 32 &> (stbox, stbox), + OPERATOR 34 />> (stbox, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (stbox, stbox), + OPERATOR 35 /&> (stbox, tgeompoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal); + +/*****************************************************************************/ + +CREATE OPERATOR CLASS stbox_kdtree_ops + FOR TYPE stbox USING spgist AS + -- strictly left + OPERATOR 1 << (stbox, stbox), + OPERATOR 1 << (stbox, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (stbox, stbox), + OPERATOR 2 &< (stbox, tgeompoint), + -- overlaps + OPERATOR 3 && (stbox, stbox), + OPERATOR 3 && (stbox, tgeompoint), + OPERATOR 3 && (stbox, tgeogpoint), + -- overlaps or right + OPERATOR 4 &> (stbox, stbox), + OPERATOR 4 &> (stbox, tgeompoint), + -- strictly right + OPERATOR 5 >> (stbox, stbox), + OPERATOR 5 >> (stbox, tgeompoint), + -- same + OPERATOR 6 ~= (stbox, stbox), + OPERATOR 6 ~= (stbox, tgeompoint), + OPERATOR 6 ~= (stbox, tgeogpoint), + -- contains + OPERATOR 7 @> (stbox, stbox), + OPERATOR 7 @> (stbox, tgeompoint), + OPERATOR 7 @> (stbox, tgeogpoint), + -- contained by + OPERATOR 8 <@ (stbox, stbox), + OPERATOR 8 <@ (stbox, tgeompoint), + OPERATOR 8 <@ (stbox, tgeogpoint), + -- overlaps or below + OPERATOR 9 &<| (stbox, stbox), + OPERATOR 9 &<| (stbox, tgeompoint), + -- strictly below + OPERATOR 10 <<| (stbox, stbox), + OPERATOR 10 <<| (stbox, tgeompoint), + -- strictly above + OPERATOR 11 |>> (stbox, stbox), + OPERATOR 11 |>> (stbox, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (stbox, stbox), + OPERATOR 12 |&> (stbox, tgeompoint), + -- adjacent + OPERATOR 17 -|- (stbox, stbox), + OPERATOR 17 -|- (stbox, tgeompoint), + OPERATOR 17 -|- (stbox, tgeogpoint), + -- overlaps or before + OPERATOR 28 &<# (stbox, stbox), + OPERATOR 28 &<# (stbox, tgeompoint), + OPERATOR 28 &<# (stbox, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (stbox, stbox), + OPERATOR 29 <<# (stbox, tgeompoint), + OPERATOR 29 <<# (stbox, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (stbox, stbox), + OPERATOR 30 #>> (stbox, tgeompoint), + OPERATOR 30 #>> (stbox, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (stbox, stbox), + OPERATOR 31 #&> (stbox, tgeompoint), + OPERATOR 31 #&> (stbox, tgeogpoint), + -- overlaps or front + OPERATOR 32 &> (stbox, stbox), + OPERATOR 34 />> (stbox, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (stbox, stbox), + OPERATOR 35 /&> (stbox, tgeompoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeompoint_quadtree_ops + DEFAULT FOR TYPE tgeompoint USING spgist AS + -- strictly left + OPERATOR 1 << (tgeompoint, stbox), + OPERATOR 1 << (tgeompoint, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (tgeompoint, stbox), + OPERATOR 2 &< (tgeompoint, tgeompoint), + -- overlaps + OPERATOR 3 && (tgeompoint, tstzspan), + OPERATOR 3 && (tgeompoint, stbox), + OPERATOR 3 && (tgeompoint, tgeompoint), + -- overlaps or right + OPERATOR 4 &> (tgeompoint, stbox), + OPERATOR 4 &> (tgeompoint, tgeompoint), + -- strictly right + OPERATOR 5 >> (tgeompoint, stbox), + OPERATOR 5 >> (tgeompoint, tgeompoint), + -- same + OPERATOR 6 ~= (tgeompoint, tstzspan), + OPERATOR 6 ~= (tgeompoint, stbox), + OPERATOR 6 ~= (tgeompoint, tgeompoint), + -- contains + OPERATOR 7 @> (tgeompoint, tstzspan), + OPERATOR 7 @> (tgeompoint, stbox), + OPERATOR 7 @> (tgeompoint, tgeompoint), + -- contained by + OPERATOR 8 <@ (tgeompoint, tstzspan), + OPERATOR 8 <@ (tgeompoint, stbox), + OPERATOR 8 <@ (tgeompoint, tgeompoint), + -- overlaps or below + OPERATOR 9 &<| (tgeompoint, stbox), + OPERATOR 9 &<| (tgeompoint, tgeompoint), + -- strictly below + OPERATOR 10 <<| (tgeompoint, stbox), + OPERATOR 10 <<| (tgeompoint, tgeompoint), + -- strictly above + OPERATOR 11 |>> (tgeompoint, stbox), + OPERATOR 11 |>> (tgeompoint, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (tgeompoint, stbox), + OPERATOR 12 |&> (tgeompoint, tgeompoint), + -- adjacent + OPERATOR 17 -|- (tgeompoint, tstzspan), + OPERATOR 17 -|- (tgeompoint, stbox), + OPERATOR 17 -|- (tgeompoint, tgeompoint), + -- nearest approach distance + OPERATOR 25 |=| (tgeompoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeompoint, tgeompoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeompoint, tstzspan), + OPERATOR 28 &<# (tgeompoint, stbox), + OPERATOR 28 &<# (tgeompoint, tgeompoint), + -- strictly before + OPERATOR 29 <<# (tgeompoint, tstzspan), + OPERATOR 29 <<# (tgeompoint, stbox), + OPERATOR 29 <<# (tgeompoint, tgeompoint), + -- strictly after + OPERATOR 30 #>> (tgeompoint, tstzspan), + OPERATOR 30 #>> (tgeompoint, stbox), + OPERATOR 30 #>> (tgeompoint, tgeompoint), + -- overlaps or after + OPERATOR 31 #&> (tgeompoint, tstzspan), + OPERATOR 31 #&> (tgeompoint, stbox), + OPERATOR 31 #&> (tgeompoint, tgeompoint), + -- overlaps or front + OPERATOR 32 &> (tgeompoint, stbox), + OPERATOR 34 />> (tgeompoint, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (tgeompoint, stbox), + OPERATOR 35 /&> (tgeompoint, tgeompoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeompoint_kdtree_ops + FOR TYPE tgeompoint USING spgist AS + -- strictly left + OPERATOR 1 << (tgeompoint, stbox), + OPERATOR 1 << (tgeompoint, tgeompoint), + -- overlaps or left + OPERATOR 2 &< (tgeompoint, stbox), + OPERATOR 2 &< (tgeompoint, tgeompoint), + -- overlaps + OPERATOR 3 && (tgeompoint, tstzspan), + OPERATOR 3 && (tgeompoint, stbox), + OPERATOR 3 && (tgeompoint, tgeompoint), + -- overlaps or right + OPERATOR 4 &> (tgeompoint, stbox), + OPERATOR 4 &> (tgeompoint, tgeompoint), + -- strictly right + OPERATOR 5 >> (tgeompoint, stbox), + OPERATOR 5 >> (tgeompoint, tgeompoint), + -- same + OPERATOR 6 ~= (tgeompoint, tstzspan), + OPERATOR 6 ~= (tgeompoint, stbox), + OPERATOR 6 ~= (tgeompoint, tgeompoint), + -- contains + OPERATOR 7 @> (tgeompoint, tstzspan), + OPERATOR 7 @> (tgeompoint, stbox), + OPERATOR 7 @> (tgeompoint, tgeompoint), + -- contained by + OPERATOR 8 <@ (tgeompoint, tstzspan), + OPERATOR 8 <@ (tgeompoint, stbox), + OPERATOR 8 <@ (tgeompoint, tgeompoint), + -- overlaps or below + OPERATOR 9 &<| (tgeompoint, stbox), + OPERATOR 9 &<| (tgeompoint, tgeompoint), + -- strictly below + OPERATOR 10 <<| (tgeompoint, stbox), + OPERATOR 10 <<| (tgeompoint, tgeompoint), + -- strictly above + OPERATOR 11 |>> (tgeompoint, stbox), + OPERATOR 11 |>> (tgeompoint, tgeompoint), + -- overlaps or above + OPERATOR 12 |&> (tgeompoint, stbox), + OPERATOR 12 |&> (tgeompoint, tgeompoint), + -- adjacent + OPERATOR 17 -|- (tgeompoint, tstzspan), + OPERATOR 17 -|- (tgeompoint, stbox), + OPERATOR 17 -|- (tgeompoint, tgeompoint), + -- nearest approach distance + OPERATOR 25 |=| (tgeompoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeompoint, tgeompoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeompoint, tstzspan), + OPERATOR 28 &<# (tgeompoint, stbox), + OPERATOR 28 &<# (tgeompoint, tgeompoint), + -- strictly before + OPERATOR 29 <<# (tgeompoint, tstzspan), + OPERATOR 29 <<# (tgeompoint, stbox), + OPERATOR 29 <<# (tgeompoint, tgeompoint), + -- strictly after + OPERATOR 30 #>> (tgeompoint, tstzspan), + OPERATOR 30 #>> (tgeompoint, stbox), + OPERATOR 30 #>> (tgeompoint, tgeompoint), + -- overlaps or after + OPERATOR 31 #&> (tgeompoint, tstzspan), + OPERATOR 31 #&> (tgeompoint, stbox), + OPERATOR 31 #&> (tgeompoint, tgeompoint), + -- overlaps or front + OPERATOR 32 &> (tgeompoint, stbox), + OPERATOR 34 />> (tgeompoint, tgeompoint), + -- overlaps or back + OPERATOR 35 /&> (tgeompoint, stbox), + OPERATOR 35 /&> (tgeompoint, tgeompoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeogpoint_quadtree_ops + DEFAULT FOR TYPE tgeogpoint USING spgist AS + -- overlaps + OPERATOR 3 && (tgeogpoint, tstzspan), + OPERATOR 3 && (tgeogpoint, stbox), + OPERATOR 3 && (tgeogpoint, tgeogpoint), + -- same + OPERATOR 6 ~= (tgeogpoint, tstzspan), + OPERATOR 6 ~= (tgeogpoint, stbox), + OPERATOR 6 ~= (tgeogpoint, tgeogpoint), + -- contains + OPERATOR 7 @> (tgeogpoint, tstzspan), + OPERATOR 7 @> (tgeogpoint, stbox), + OPERATOR 7 @> (tgeogpoint, tgeogpoint), + -- contained by + OPERATOR 8 <@ (tgeogpoint, tstzspan), + OPERATOR 8 <@ (tgeogpoint, stbox), + OPERATOR 8 <@ (tgeogpoint, tgeogpoint), + -- adjacent + OPERATOR 17 -|- (tgeogpoint, tstzspan), + OPERATOR 17 -|- (tgeogpoint, stbox), + OPERATOR 17 -|- (tgeogpoint, tgeogpoint), + -- nearest approach distance + OPERATOR 25 |=| (tgeogpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeogpoint, tgeogpoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeogpoint, tstzspan), + OPERATOR 28 &<# (tgeogpoint, stbox), + OPERATOR 28 &<# (tgeogpoint, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (tgeogpoint, tstzspan), + OPERATOR 29 <<# (tgeogpoint, stbox), + OPERATOR 29 <<# (tgeogpoint, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (tgeogpoint, tstzspan), + OPERATOR 30 #>> (tgeogpoint, stbox), + OPERATOR 30 #>> (tgeogpoint, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (tgeogpoint, tstzspan), + OPERATOR 31 #&> (tgeogpoint, stbox), + OPERATOR 31 #&> (tgeogpoint, tgeogpoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tgeogpoint_kdtree_ops + FOR TYPE tgeogpoint USING spgist AS + -- overlaps + OPERATOR 3 && (tgeogpoint, tstzspan), + OPERATOR 3 && (tgeogpoint, tgeogpoint), + -- same + OPERATOR 6 ~= (tgeogpoint, tstzspan), + OPERATOR 6 ~= (tgeogpoint, stbox), + OPERATOR 6 ~= (tgeogpoint, tgeogpoint), + -- contains + OPERATOR 7 @> (tgeogpoint, tstzspan), + OPERATOR 7 @> (tgeogpoint, stbox), + OPERATOR 7 @> (tgeogpoint, tgeogpoint), + -- contained by + OPERATOR 8 <@ (tgeogpoint, tstzspan), + OPERATOR 8 <@ (tgeogpoint, stbox), + OPERATOR 8 <@ (tgeogpoint, tgeogpoint), + -- adjacent + OPERATOR 17 -|- (tgeogpoint, tstzspan), + OPERATOR 17 -|- (tgeogpoint, stbox), + OPERATOR 17 -|- (tgeogpoint, tgeogpoint), + -- nearest approach distance + OPERATOR 25 |=| (tgeogpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tgeogpoint, tgeogpoint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tgeogpoint, tstzspan), + OPERATOR 28 &<# (tgeogpoint, stbox), + OPERATOR 28 &<# (tgeogpoint, tgeogpoint), + -- strictly before + OPERATOR 29 <<# (tgeogpoint, tstzspan), + OPERATOR 29 <<# (tgeogpoint, stbox), + OPERATOR 29 <<# (tgeogpoint, tgeogpoint), + -- strictly after + OPERATOR 30 #>> (tgeogpoint, tstzspan), + OPERATOR 30 #>> (tgeogpoint, stbox), + OPERATOR 30 #>> (tgeogpoint, tgeogpoint), + -- overlaps or after + OPERATOR 31 #&> (tgeogpoint, tstzspan), + OPERATOR 31 #&> (tgeogpoint, stbox), + OPERATOR 31 #&> (tgeogpoint, tgeogpoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tgeo_analytics.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tgeo_analytics.in.sql new file mode 100644 index 0000000..b30dc84 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tgeo_analytics.in.sql @@ -0,0 +1,149 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Analytic functions for temporal geometries + */ + +/*****************************************************************************/ +-- Affine transforms + +CREATE OR REPLACE FUNCTION affine(tgeometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Tgeo_affine' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION affine(tgeometry,float8,float8,float8,float8,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, $2, $3, 0, $4, $5, 0, 0, 0, 1, $6, $7, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeometry,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeometry,float8,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, $3 - cos($2) * $3 + sin($2) * $4, $4 - sin($2) * $3 - cos($2) * $4, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeometry,float8,geometry) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, @extschema@.ST_X($3) - cos($2) * @extschema@.ST_X($3) + sin($2) * @extschema@.ST_Y($3), @extschema@.ST_Y($3) - sin($2) * @extschema@.ST_X($3) - cos($2) * @extschema@.ST_Y($3), 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateZ(tgeometry,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.rotate($1, $2)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateX(tgeometry,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, 1, 0, 0, 0, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateY(tgeometry,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, cos($2), 0, sin($2), 0, 1, 0, -sin($2), 0, cos($2), 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION translate(tgeometry,float8,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, 1, 0, 0, 0, 1, 0, 0, 0, 1, $2, $3, $4)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION translate(tgeometry,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.translate($1, $2, $3, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION transscale(tgeometry,float8,float8,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.affine($1, $4, 0, 0, 0, $5, 0, 0, 0, 1, $2 * $4, $3 * $5, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeometry,geometry) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Tgeo_scale' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeometry,geometry,origin geometry) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Tgeo_scale' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeometry,float8,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.scale($1, @extschema@.ST_MakePoint($2, $3, $4))' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeometry,float8,float8) +RETURNS tgeometry +AS 'SELECT @extschema@.scale($1, $2, $3, 1)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION minDistSimplify(tgeometry, float) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistSimplify(tgeography, float) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minTimeDeltaSimplify(tgeometry, interval) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_tdelta' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minTimeDeltaSimplify(tgeography, interval) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_tdelta' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION maxDistSimplify(tgeometry, float, boolean DEFAULT TRUE) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_max_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION douglasPeuckerSimplify(tgeometry, float, boolean DEFAULT TRUE) +RETURNS tgeometry +AS 'MODULE_PATHNAME', 'Temporal_simplify_dp' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION asMVTGeom(tgeo tgeometry, bounds stbox, + -- extent int4 DEFAULT 4096, buffer int4 DEFAULT 256, clip bool DEFAULT TRUE) +-- RETURNS geom_times +-- AS 'MODULE_PATHNAME','Tgeo_AsMVTGeom' +-- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tpoint_analytics.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tpoint_analytics.in.sql new file mode 100644 index 0000000..017b404 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/076_tpoint_analytics.in.sql @@ -0,0 +1,208 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Analytic functions for temporal points + */ + +/*****************************************************************************/ +-- There are two versions of the functions since the single-argument version +-- is required for defining the casting + +CREATE FUNCTION geometry(tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tpoint_to_geomeas' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geometry(tgeompoint, boolean DEFAULT FALSE) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tpoint_to_geomeas' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeompoint AS geometry) WITH FUNCTION geometry(tgeompoint); + +CREATE FUNCTION geography(tgeogpoint) + RETURNS geography + AS 'MODULE_PATHNAME', 'Tpoint_to_geomeas' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION geography(tgeogpoint, boolean DEFAULT FALSE) + RETURNS geography + AS 'MODULE_PATHNAME', 'Tpoint_to_geomeas' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tgeogpoint AS geography) WITH FUNCTION geography(tgeogpoint); + +CREATE FUNCTION tgeompoint(geometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Geomeas_to_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (geometry AS tgeompoint) WITH FUNCTION tgeompoint(geometry); + +CREATE FUNCTION tgeogpoint(geography) + RETURNS tgeogpoint + AS 'MODULE_PATHNAME', 'Geomeas_to_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (geography AS tgeogpoint) WITH FUNCTION tgeogpoint(geography); + +/*****************************************************************************/ + +CREATE FUNCTION geoMeasure(tgeompoint, tfloat, boolean DEFAULT FALSE) +RETURNS geometry +AS 'MODULE_PATHNAME', 'Tpoint_tfloat_to_geomeas' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION geoMeasure(tgeogpoint, tfloat, boolean DEFAULT FALSE) +RETURNS geography +AS 'MODULE_PATHNAME', 'Tpoint_tfloat_to_geomeas' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ +-- Affine transforms + +CREATE OR REPLACE FUNCTION affine(tgeompoint,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Tgeo_affine' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION affine(tgeompoint,float8,float8,float8,float8,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, $2, $3, 0, $4, $5, 0, 0, 0, 1, $6, $7, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeompoint,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeompoint,float8,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, $3 - cos($2) * $3 + sin($2) * $4, $4 - sin($2) * $3 - cos($2) * $4, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotate(tgeompoint,float8,geometry) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0, 1, @extschema@.ST_X($3) - cos($2) * @extschema@.ST_X($3) + sin($2) * @extschema@.ST_Y($3), @extschema@.ST_Y($3) - sin($2) * @extschema@.ST_X($3) - cos($2) * @extschema@.ST_Y($3), 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateZ(tgeompoint,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.rotate($1, $2)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateX(tgeompoint,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, 1, 0, 0, 0, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION rotateY(tgeompoint,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, cos($2), 0, sin($2), 0, 1, 0, -sin($2), 0, cos($2), 0, 0, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION translate(tgeompoint,float8,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, 1, 0, 0, 0, 1, 0, 0, 0, 1, $2, $3, $4)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION translate(tgeompoint,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.translate($1, $2, $3, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION transscale(tgeompoint,float8,float8,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.affine($1, $4, 0, 0, 0, $5, 0, 0, 0, 1, $2 * $4, $3 * $5, 0)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeompoint,geometry) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Tgeo_scale' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeompoint,geometry,origin geometry) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Tgeo_scale' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeompoint,float8,float8,float8) +RETURNS tgeompoint +--AS 'SELECT affine($1, $2, 0, 0, 0, $3, 0, 0, 0, $4, 0, 0, 0)' +AS 'SELECT @extschema@.scale($1, @extschema@.ST_MakePoint($2, $3, $4))' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OR REPLACE FUNCTION scale(tgeompoint,float8,float8) +RETURNS tgeompoint +AS 'SELECT @extschema@.scale($1, $2, $3, 1)' +LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION minDistSimplify(tgeompoint, float) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minDistSimplify(tgeogpoint, float) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minTimeDeltaSimplify(tgeompoint, interval) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_tdelta' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minTimeDeltaSimplify(tgeogpoint, interval) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_tdelta' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION maxDistSimplify(tgeompoint, float, boolean DEFAULT TRUE) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_max_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION douglasPeuckerSimplify(tgeompoint, float, boolean DEFAULT TRUE) +RETURNS tgeompoint +AS 'MODULE_PATHNAME', 'Temporal_simplify_dp' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE geom_times AS ( + geom geometry, + times bigint[] +); + +CREATE FUNCTION asMVTGeom(tpoint tgeompoint, bounds stbox, + extent int4 DEFAULT 4096, buffer int4 DEFAULT 256, clip bool DEFAULT TRUE) +-- RETURNS tgeompoint +RETURNS geom_times +AS 'MODULE_PATHNAME','Tpoint_AsMVTGeom' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/078_tpoint_datagen.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/078_tpoint_datagen.in.sql new file mode 100644 index 0000000..2284e6d --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/078_tpoint_datagen.in.sql @@ -0,0 +1,40 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Data generator for MobilityDB + */ + +CREATE FUNCTION create_trip(record[], timestamptz, boolean, text) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Create_trip' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/CMakeLists.txt new file mode 100644 index 0000000..1fc2fc2 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/geo/CMakeLists.txt @@ -0,0 +1,47 @@ +SET(LOCAL_FILES + 050_geoset + 051_stbox + 052_tpoint + 053_tpoint_inout + 054_tpoint_compops + 056_tpoint_spatialfuncs + 058_tpoint_tile + 060_tpoint_boxops + 062_tpoint_posops + 064_tpoint_distance + 066_tpoint_similarity + 068_tpoint_aggfuncs + 070_tpoint_spatialrels + 072_tpoint_tempspatialrels + 073_tpoint_gist + 074_tpoint_spgist + 076_tpoint_analytics + 078_tpoint_datagen + ) + +# Files added for temporal geometries +# TODO These files should be added to the list above +list(APPEND LOCAL_FILES + 052_tgeo + 053_tgeo_inout + 054_tgeo_compops + 056_tgeo_spatialfuncs + 058_tgeo_tile + 060_tgeo_boxops + 062_tgeo_posops + 064_tgeo_distance + 068_tgeo_aggfuncs + 070_tgeo_spatialrels + 072_tgeo_tempspatialrels + 073_tgeo_gist + 074_tgeo_spgist + 076_tgeo_analytics + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/mobilitydb.in.control b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/mobilitydb.in.control new file mode 100644 index 0000000..2841a47 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/mobilitydb.in.control @@ -0,0 +1,5 @@ +comment = 'MobilityDB geospatial trajectory data management & analysis platform' +default_version = '${MOBILITYDB_VERSION}' +module_pathname = '${MOBILITYDB_MODULE_PATHNAME}' +relocatable = false +requires = 'postgis' diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/081_npoint.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/081_npoint.in.sql new file mode 100644 index 0000000..3c1aadb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/081_npoint.in.sql @@ -0,0 +1,424 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Network-based static point and segment types + */ + +CREATE TYPE npoint; +CREATE TYPE nsegment; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION npoint_in(cstring) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_in' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION npoint_out(npoint) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Npoint_out' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION npoint_recv(internal) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_recv' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION npoint_send(npoint) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Npoint_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE npoint ( + internallength = 16, + input = npoint_in, + output = npoint_out, + receive = npoint_recv, + send = npoint_send, + alignment = double +); + +CREATE FUNCTION nsegment_in(cstring) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Nsegment_in' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION nsegment_out(nsegment) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Nsegment_out' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION nsegment_recv(internal) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Nsegment_recv' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION nsegment_send(nsegment) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Nsegment_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE nsegment ( + internallength = 24, + input = nsegment_in, + output = nsegment_out, + receive = nsegment_recv, + send = nsegment_send, + alignment = double +); + +/***************************************************************************** + * Input/output from (E)WKT, (E)WKB and HexEWKB representation + *****************************************************************************/ + +CREATE FUNCTION npointFromText(text) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION npointFromEWKT(text) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION npointFromBinary(bytea) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION npointFromEWKB(bytea) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION npointFromHexEWKB(text) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asText(npoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Npoint_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(npoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(npoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Npoint_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(npoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(npoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Npoint_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(npoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Npoint_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(npoint, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Npoint_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION npoint(bigint, double precision) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nsegment(bigint, double precision DEFAULT 0, double precision DEFAULT 1) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Nsegment_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nsegment(npoint) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Npoint_to_nsegment' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (npoint AS nsegment) WITH FUNCTION nsegment(npoint); + +/***************************************************************************** + * Conversion between network and space + *****************************************************************************/ + +CREATE FUNCTION geometry(npoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Npoint_to_geompoint' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION npoint(geometry) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Geompoint_to_npoint' + LANGUAGE C IMMUTABLE STRICT; + +CREATE CAST (npoint AS geometry) WITH FUNCTION geometry(npoint); +CREATE CAST (geometry AS npoint) WITH FUNCTION npoint(geometry); + +CREATE FUNCTION geometry(nsegment) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Nsegment_to_geom' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION nsegment(geometry) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Geom_to_nsegment' + LANGUAGE C IMMUTABLE STRICT; + +CREATE CAST (nsegment AS geometry) WITH FUNCTION geometry(nsegment); +CREATE CAST (geometry AS nsegment) WITH FUNCTION nsegment(geometry); + +/***************************************************************************** + * Accessors + *****************************************************************************/ + +CREATE FUNCTION route(npoint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Npoint_route' + LANGUAGE C IMMUTABLE STRICT; + +-- position is a reserved word in SQL +CREATE FUNCTION getPosition(npoint) + RETURNS double precision + AS 'MODULE_PATHNAME', 'Npoint_position' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION srid(npoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Npoint_srid' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION route(nsegment) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Nsegment_route' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION startPosition(nsegment) + RETURNS double precision + AS 'MODULE_PATHNAME', 'Nsegment_start_position' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION endPosition(nsegment) + RETURNS double precision + AS 'MODULE_PATHNAME', 'Nsegment_end_position' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION srid(nsegment) + RETURNS integer + AS 'MODULE_PATHNAME', 'Nsegment_srid' + LANGUAGE C IMMUTABLE STRICT; + +/***************************************************************************** + * Modification functions + *****************************************************************************/ + +CREATE FUNCTION round(npoint, integer DEFAULT 0) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Npoint_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(nsegment, integer DEFAULT 0) + RETURNS nsegment + AS 'MODULE_PATHNAME', 'Nsegment_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Comparisons + ******************************************************************************/ + +CREATE FUNCTION npoint_eq(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_ne(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_lt(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_le(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_ge(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_gt(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npoint_cmp(npoint, npoint) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Npoint_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + PROCEDURE = npoint_eq, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = npoint_ne, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = npoint_lt, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = npoint_le, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = npoint_ge, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargesel, JOIN = scalargejoinsel +); +CREATE OPERATOR > ( + PROCEDURE = npoint_gt, + LEFTARG = npoint, RIGHTARG = npoint, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS npoint_btree_ops + DEFAULT FOR TYPE npoint USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 npoint_cmp(npoint, npoint); + +/******************************************************************************/ + +CREATE FUNCTION nsegment_eq(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_ne(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_lt(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_le(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_ge(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_gt(nsegment, nsegment) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Nsegment_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nsegment_cmp(nsegment, nsegment) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Nsegment_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + PROCEDURE = nsegment_eq, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = nsegment_ne, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = nsegment_lt, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = nsegment_le, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = nsegment_ge, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargesel, JOIN = scalargejoinsel +); +CREATE OPERATOR > ( + PROCEDURE = nsegment_gt, + LEFTARG = nsegment, RIGHTARG = nsegment, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS nsegment_btree_ops + DEFAULT FOR TYPE nsegment USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 nsegment_cmp(nsegment, nsegment); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/082_npointset.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/082_npointset.in.sql new file mode 100644 index 0000000..4d11ece --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/082_npointset.in.sql @@ -0,0 +1,507 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for set of network point values + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE npointset; + +CREATE FUNCTION npointset_in(cstring) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointset_out(npointset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointset_recv(internal) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointset_send(npointset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE npointset ( + internallength = variable, + input = npointset_in, + output = npointset_out, + receive = npointset_recv, + send = npointset_send, + alignment = double, + storage = extended + -- , analyze = geoset_analyze +); + +/******************************************************************************/ + +-- Input/output in WKT, WKB, and HexWKB representation + +CREATE FUNCTION npointsetFromText(text) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointsetFromEWKT(text) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION npointsetFromBinary(bytea) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointsetFromEWKB(bytea) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION npointsetFromHexWKB(text) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(npointset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(npointset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(npointset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKB(npointset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(npointset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor + ******************************************************************************/ + +CREATE FUNCTION set(npoint[]) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversions + ******************************************************************************/ + +CREATE FUNCTION set(npoint) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION stbox(npointset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Spatialset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (npoint AS npointset) WITH FUNCTION set(npoint); +CREATE CAST (npointset AS stbox) WITH FUNCTION stbox(npointset); + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION round(npointset, integer DEFAULT 0) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION memSize(npointset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numValues(npointset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(npointset) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(npointset) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(npointset, integer) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getValues(npointset) + RETURNS npoint[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION routes(npointset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Npointset_routes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation set of values <-> set + ******************************************************************************/ + +CREATE FUNCTION unnest(npointset) + RETURNS SETOF npoint + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, npoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, npointset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION npointset_union_finalfn(internal) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE setUnion(npoint) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = npointset_union_finalfn +); +CREATE AGGREGATE setUnion(npointset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = npointset_union_finalfn +); + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION set_eq(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(npointset, npointset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(npointset, npointset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >= + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = > + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = < + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = npointset, RIGHTARG = npointset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <= + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS npointset_btree_ops + DEFAULT FOR TYPE npointset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(npointset, npointset); + +/******************************************************************************/ + +CREATE FUNCTION set_hash(npointset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(npointset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS npointset_hash_ops + DEFAULT FOR TYPE npointset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(npointset), + FUNCTION 2 set_hash_extended(npointset, bigint); + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION set_contains(npointset, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(npointset, npointset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = npointset, RIGHTARG = npoint, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_contained(npoint, npointset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(npointset, npointset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = npoint, RIGHTARG = npointset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overlaps(npointset, npointset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = && + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION set_union(npoint, npointset) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(npointset, npoint) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(npointset, npointset) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = npoint, RIGHTARG = npointset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = npointset, RIGHTARG = npoint, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION set_minus(npoint, npointset) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(npointset, npoint) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(npointset, npointset) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = npoint, RIGHTARG = npointset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = npointset, RIGHTARG = npoint +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = npointset, RIGHTARG = npointset +); + +/*****************************************************************************/ + +CREATE FUNCTION set_intersection(npoint, npointset) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(npointset, npoint) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(npointset, npointset) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = npoint, RIGHTARG = npointset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = npointset, RIGHTARG = npoint, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = * +); + +/*****************************************************************************/ + +CREATE FUNCTION set_distance(npoint, npointset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(npointset, npoint) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(npointset, npointset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = npoint, RIGHTARG = npointset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = npointset, RIGHTARG = npoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = npointset, RIGHTARG = npointset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/083_tnpoint.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/083_tnpoint.in.sql new file mode 100644 index 0000000..efea630 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/083_tnpoint.in.sql @@ -0,0 +1,664 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal network points + */ + +CREATE TYPE tnpoint; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION tnpoint_in(cstring, oid, integer) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Temporal_out(tnpoint) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpoint_recv(internal, oid, integer) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tnpoint) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tnpoint ( + internallength = variable, + input = tnpoint_in, + output = temporal_out, + receive = tnpoint_recv, + send = temporal_send, + typmod_in = temporal_typmod_in, + typmod_out = temporal_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tnpoint(tnpoint, integer) + RETURNS tnpoint + AS 'MODULE_PATHNAME','Temporal_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tnpoint AS tnpoint) WITH FUNCTION tnpoint(tnpoint, integer) AS IMPLICIT; + +/***************************************************************************** + * Input/output from (E)WKT, (E)WKB, and HexEWKB + *****************************************************************************/ + +CREATE FUNCTION tnpointFromBinary(bytea) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpointFromHexWKB(text) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asText(tnpoint, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tnpoint[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tnpoint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(tnpoint, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION tnpoint(npoint, timestamptz) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpoint(npoint, tstzset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpoint(npoint, tstzspan, text DEFAULT 'linear') + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpoint(npoint, tstzspanset, text DEFAULT 'linear') + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tnpointSeq(tnpoint[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpointSeqSet(tnpoint[]) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tnpointSeqSetGaps(tnpoint[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/****************************************************************************** + * Cast functions + ******************************************************************************/ + +CREATE FUNCTION tgeompoint(tnpoint) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tnpoint_to_tgeompoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnpoint(tgeompoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tgeompoint_to_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tnpoint) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tnpoint AS tgeompoint) WITH FUNCTION tgeompoint(tnpoint); +CREATE CAST (tgeompoint AS tnpoint) WITH FUNCTION tnpoint(tgeompoint); +CREATE CAST (tnpoint AS tstzspan) WITH FUNCTION timeSpan(tnpoint); + +/****************************************************************************** + * Transformation functions + ******************************************************************************/ + +CREATE FUNCTION tnpointInst(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tnpointSeq(tnpoint, text) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tnpointSeq(tnpoint) + RETURNS tnpoint + AS 'SELECT @extschema@.tnpointSeq($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tnpointSeqSet(tnpoint, text) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tnpointSeqSet(tnpoint) + RETURNS tnpoint + AS 'SELECT @extschema@.tnpointSeqSet($1, NULL)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tnpoint, text) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tnpoint, integer DEFAULT 0) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tnpoint[], integer DEFAULT 0) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Append functions + ******************************************************************************/ + +CREATE FUNCTION appendInstant(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tnpoint[]) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION tempSubtype(tnpoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tnpoint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(tnpoint) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- values is a reserved word in SQL +CREATE FUNCTION getValues(tnpoint) + RETURNS npointset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION positions(tnpoint) + RETURNS nsegment[] + AS 'MODULE_PATHNAME', 'Tnpoint_positions' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION route(tnpoint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Tnpoint_route' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION routes(tnpoint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Tnpoint_routes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tnpoint) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getTimestamp(tnpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tnpoint) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tnpoint) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tnpoint, int) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tnpoint, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tnpoint, integer) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tnpoint) + RETURNS tnpoint[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tnpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tnpoint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tnpoint, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tnpoint) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tnpoint, integer) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tnpoint) + RETURNS tnpoint[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tnpoint) + RETURNS tnpoint[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION shiftTime(tnpoint, interval) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tnpoint, interval) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tnpoint, interval, interval) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE TYPE npoint_tstzspanset AS ( + value npoint, + time tstzspanset +); + +CREATE FUNCTION unnest(tnpoint) + RETURNS SETOF npoint_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Restriction functions + ******************************************************************************/ + +CREATE FUNCTION atValues(tnpoint, npoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_at_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tnpoint, npoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_minus_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tnpoint, npointset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_at_npointset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tnpoint, npointset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_minus_npointset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tnpoint, timestamptz) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tnpoint, timestamptz) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tnpoint, timestamptz) + RETURNS npoint + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tnpoint, tstzset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tnpoint, tstzset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tnpoint, tstzspan) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tnpoint, tstzspan) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tnpoint, tstzspanset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tnpoint, tstzspanset) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tnpoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tnpoint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stop Function + *****************************************************************************/ + +CREATE FUNCTION stops(tnpoint, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tnpoint, tnpoint, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tnpoint, tnpoint, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tnpoint, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tnpoint, tstzset, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tnpoint, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tnpoint, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE time_tnpoint AS ( + time timestamptz, + temp tnpoint +); + +CREATE FUNCTION timeSplit(tnpoint, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tnpoint + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tnpoint, tnpoint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tnpoint, tnpoint) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS tnpoint_btree_ops + DEFAULT FOR TYPE tnpoint USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tnpoint, tnpoint); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tnpoint_hash_ops + DEFAULT FOR TYPE tnpoint USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tnpoint); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/085_tnpoint_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/085_tnpoint_compops.in.sql new file mode 100644 index 0000000..033ae3c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/085_tnpoint_compops.in.sql @@ -0,0 +1,233 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever/always and temporal comparisons for temporal network points + */ + +/***************************************************************************** + * Ever/Always comparisons + *****************************************************************************/ + +CREATE FUNCTION ever_eq(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = npoint, RIGHTARG = tnpoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tnpoint, RIGHTARG = npoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = npoint, RIGHTARG = tnpoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tnpoint, RIGHTARG = npoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION always_eq(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = npoint, RIGHTARG = tnpoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tnpoint, RIGHTARG = npoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION always_ne(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = npoint, RIGHTARG = tnpoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tnpoint, RIGHTARG = npoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal comparisons + *****************************************************************************/ + +CREATE FUNCTION temporal_teq(npoint, tnpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tnpoint, npoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tnpoint, tnpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = npoint, RIGHTARG = tnpoint, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tnpoint, RIGHTARG = npoint, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_tne(npoint, tnpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tnpoint, npoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tnpoint, tnpoint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = npoint, RIGHTARG = tnpoint, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tnpoint, RIGHTARG = npoint, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = #<> +); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/087_tnpoint_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/087_tnpoint_spatialfuncs.in.sql new file mode 100644 index 0000000..fb43524 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/087_tnpoint_spatialfuncs.in.sql @@ -0,0 +1,148 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Geometric functions for temporal network points + */ + +/***************************************************************************** + * SRID + *****************************************************************************/ + +CREATE FUNCTION SRID(tnpoint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Trajectory + *****************************************************************************/ + +CREATE FUNCTION trajectory(tnpoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tnpoint_trajectory' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * AtGeometry and MinusGeometry + *****************************************************************************/ + +CREATE FUNCTION atGeometry(tnpoint, geometry) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_at_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusGeometry(tnpoint, geometry) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_minus_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atStbox(tnpoint, stbox, bool DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_at_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusStbox(tnpoint, stbox, bool DEFAULT TRUE) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Tnpoint_minus_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Equals + *****************************************************************************/ + +CREATE FUNCTION same(npoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Npoint_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Length + *****************************************************************************/ + +CREATE FUNCTION length(tnpoint) + RETURNS double precision + AS 'MODULE_PATHNAME', 'Tnpoint_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Cumulative length + *****************************************************************************/ + +CREATE FUNCTION cumulativeLength(tnpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnpoint_cumulative_length' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Speed + *****************************************************************************/ + +CREATE FUNCTION speed(tnpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnpoint_speed' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Time-weighted centroid + *****************************************************************************/ + +CREATE FUNCTION twCentroid(tnpoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Tnpoint_twcentroid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Shortest line + *****************************************************************************/ + +CREATE FUNCTION shortestLine(geometry, tnpoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tnpoint, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tnpoint_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(npoint, tnpoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tnpoint, npoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tnpoint, tnpoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/089_tnpoint_topops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/089_tnpoint_topops.in.sql new file mode 100644 index 0000000..6c8a0ee --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/089_tnpoint_topops.in.sql @@ -0,0 +1,385 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal network points + */ + +/***************************************************************************** + * Temporal npoint to stbox + *****************************************************************************/ + +CREATE FUNCTION stbox(npoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Npoint_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(nsegment) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Nsegment_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(npoint, timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Npoint_timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(npoint, tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Npoint_tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(tnpoint) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (npoint AS stbox) WITH FUNCTION stbox(npoint); +CREATE CAST (nsegment AS stbox) WITH FUNCTION stbox(nsegment); +CREATE CAST (tnpoint AS stbox) WITH FUNCTION stbox(tnpoint); + +/*****************************************************************************/ + +CREATE FUNCTION expandSpace(tnpoint, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tnpoint, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tnpoint, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tnpoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contains(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tnpoint, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tnpoint, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tnpoint, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tnpoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contained(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tnpoint, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tnpoint, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tnpoint, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tnpoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_overlaps(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tnpoint, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tnpoint, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tnpoint, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tnpoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_same(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tnpoint, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tnpoint, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tnpoint, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tnpoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_adjacent(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tnpoint, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/090_tnpoint_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/090_tnpoint_posops.in.sql new file mode 100644 index 0000000..b75fdf7 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/090_tnpoint_posops.in.sql @@ -0,0 +1,487 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for temporal network points + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tnpoint */ + +CREATE FUNCTION temporal_before(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tnpoint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tnpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tnpoint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tnpoint, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tnpoint + *****************************************************************************/ + +/* tnpoint op tstzspan */ + +CREATE FUNCTION temporal_before(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tnpoint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tnpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tnpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tnpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tnpoint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* tnpoint op stbox */ + +CREATE FUNCTION temporal_left(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tnpoint, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tnpoint op tnpoint */ + +CREATE FUNCTION temporal_left(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/091_tnpoint_routeops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/091_tnpoint_routeops.in.sql new file mode 100644 index 0000000..4a59f22 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/091_tnpoint_routeops.in.sql @@ -0,0 +1,267 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Route operators for temporal network points + */ + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION overlaps_rid(bigintset, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_rid_bigintset_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @@ ( + PROCEDURE = overlaps_rid, + LEFTARG = bigintset, RIGHTARG = tnpoint, + COMMUTATOR = @@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION overlaps_rid(tnpoint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_rid_tnpoint_bigintset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION overlaps_rid(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_rid_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @@ ( + PROCEDURE = overlaps_rid, + LEFTARG = tnpoint, RIGHTARG = bigintset, + COMMUTATOR = @@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @@ ( + PROCEDURE = overlaps_rid, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = @@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION contains_rid(bigintset, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_rid_bigintset_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @? ( + PROCEDURE = contains_rid, + LEFTARG = bigintset, RIGHTARG = tnpoint, + COMMUTATOR = ?@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION contains_rid(tnpoint, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_rid_tnpoint_bigint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contains_rid(tnpoint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_rid_tnpoint_bigintset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contains_rid(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_rid_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contains_rid(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_rid_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @? ( + PROCEDURE = contains_rid, + LEFTARG = tnpoint, RIGHTARG = bigint, + COMMUTATOR = ?@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @? ( + PROCEDURE = contains_rid, + LEFTARG = tnpoint, RIGHTARG = bigintset, + COMMUTATOR = ?@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @? ( + PROCEDURE = contains_rid, + LEFTARG = tnpoint, RIGHTARG = npoint, + COMMUTATOR = ?@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @? ( + PROCEDURE = contains_rid, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = ?@ + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION contained_rid(bigint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_rid_bigint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contained_rid(bigintset, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_rid_bigintset_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contained_rid(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_rid_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?@ ( + PROCEDURE = contained_rid, + LEFTARG = bigint, RIGHTARG = tnpoint, + COMMUTATOR = @? + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?@ ( + PROCEDURE = contained_rid, + LEFTARG = bigintset, RIGHTARG = tnpoint, + COMMUTATOR = @? + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?@ ( + PROCEDURE = contained_rid, + LEFTARG = npoint, RIGHTARG = tnpoint, + COMMUTATOR = @? + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION contained_rid(tnpoint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_rid_tnpoint_bigintset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION contained_rid(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_rid_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?@ ( + PROCEDURE = contained_rid, + LEFTARG = tnpoint, RIGHTARG = bigintset, + COMMUTATOR = @? + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ?@ ( + PROCEDURE = contained_rid, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = @? + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION same_rid(bigint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_bigint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION same_rid(bigintset, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_bigintset_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION same_rid(npoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = bigint, RIGHTARG = tnpoint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = bigintset, RIGHTARG = tnpoint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = npoint, RIGHTARG = tnpoint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION same_rid(tnpoint, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_tnpoint_bigint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION same_rid(tnpoint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_tnpoint_bigintset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION same_rid(tnpoint, npoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION same_rid(tnpoint, tnpoint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_rid_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = tnpoint, RIGHTARG = bigint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = tnpoint, RIGHTARG = bigintset, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = tnpoint, RIGHTARG = npoint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @= ( + PROCEDURE = same_rid, + LEFTARG = tnpoint, RIGHTARG = tnpoint, + COMMUTATOR = @= + -- , RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/092_tnpoint_gin.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/092_tnpoint_gin.in.sql new file mode 100644 index 0000000..ddd6674 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/092_tnpoint_gin.in.sql @@ -0,0 +1,80 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief GIN index for temporal network points + */ + +/******************************************************************************/ + +CREATE FUNCTION tnpoint_gin_extract_value(bigint, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Tnpoint_gin_extract_value' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tnpoint_gin_extract_query(bigint, internal, int2, internal, internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Tnpoint_gin_extract_query' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tnpoint_gin_triconsistent(internal, int2, bigint, int4, internal, internal, internal) +RETURNS char +AS 'MODULE_PATHNAME', 'Set_gin_triconsistent' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tnpoint_gin_ops + DEFAULT FOR TYPE tnpoint USING gin AS + STORAGE bigint, + -- overlap set + OPERATOR 10 @@ (tnpoint, bigintset), + -- overlap tnpoint + OPERATOR 11 @@ (tnpoint, tnpoint), + -- contains value + OPERATOR 20 @? (tnpoint, bigint), + -- contains set + OPERATOR 21 @? (tnpoint, bigintset), + -- contains tnpoint + OPERATOR 22 @? (tnpoint, tnpoint), + -- contained set + OPERATOR 30 ?@ (tnpoint, bigintset), + -- contained tnpoint + OPERATOR 31 ?@ (tnpoint, tnpoint), + -- equal set + OPERATOR 40 @= (tnpoint, bigintset), + -- equal tnpoint + OPERATOR 41 @= (tnpoint, tnpoint), + -- functions + FUNCTION 2 tnpoint_gin_extract_value(bigint, internal), + FUNCTION 3 tnpoint_gin_extract_query(bigint, internal, int2, internal, internal, internal, internal), + FUNCTION 6 tnpoint_gin_triconsistent(internal, int2, bigint, int4, internal, internal, internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/093_tnpoint_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/093_tnpoint_distance.in.sql new file mode 100644 index 0000000..d5f54bf --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/093_tnpoint_distance.in.sql @@ -0,0 +1,187 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal network points + */ + +/***************************************************************************** + * Temporal distance + *****************************************************************************/ + +CREATE FUNCTION tDistance(geometry(Point), tnpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_point_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(npoint, tnpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tnpoint, geometry(Point)) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tnpoint_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tnpoint, npoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tnpoint, tnpoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = geometry, + RIGHTARG = tnpoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = npoint, + RIGHTARG = tnpoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tnpoint, + RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tnpoint, + RIGHTARG = npoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tnpoint, + RIGHTARG = tnpoint, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant + *****************************************************************************/ + +CREATE FUNCTION NearestApproachInstant(geometry, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'NAI_geo_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION NearestApproachInstant(tnpoint, geometry) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'NAI_tnpoint_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION NearestApproachInstant(npoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'NAI_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION NearestApproachInstant(tnpoint, npoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'NAI_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION NearestApproachInstant(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'NAI_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Nearest approach distance + *****************************************************************************/ + +CREATE FUNCTION nearestApproachDistance(geometry, tnpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tnpoint, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnpoint_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tnpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tnpoint, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnpoint_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION NearestApproachDistance(npoint, tnpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_npoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION NearestApproachDistance(tnpoint, npoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnpoint_npoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tnpoint, tnpoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnpoint_tnpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = tnpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tnpoint, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tnpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tnpoint, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = npoint, RIGHTARG = tnpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tnpoint, RIGHTARG = npoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tnpoint, RIGHTARG = tnpoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/095_tnpoint_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/095_tnpoint_aggfuncs.in.sql new file mode 100644 index 0000000..e10f8eb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/095_tnpoint_aggfuncs.in.sql @@ -0,0 +1,171 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal network points + */ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tnpoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tnpoint) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, tnpoint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(tnpoint, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION tcentroid_transfn(internal, tnpoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnpoint_tcentroid_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcentroid(tnpoint) ( + SFUNC = tcentroid_transfn, + STYPE = internal, + COMBINEFUNC = tcentroid_combinefn, + FINALFUNC = tcentroid_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tnpoint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tnpoint_tagg_finalfn(internal) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(tnpoint) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tnpoint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tnpoint, tnpoint, + interp text DEFAULT NULL) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tnpoint, tnpoint, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tnpoint) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tnpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tnpoint, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tnpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tnpoint, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tnpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tnpoint, tnpoint) + RETURNS tnpoint + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tnpoint) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tnpoint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/098_tnpoint_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/098_tnpoint_indexes.in.sql new file mode 100644 index 0000000..58d6e15 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/098_tnpoint_indexes.in.sql @@ -0,0 +1,267 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST, Quad-tree SP-GiST, and k-d tree SP-GiST indexes for + * temporal network points + */ + +/******************************************************************************/ + +CREATE FUNCTION tnpoint_gist_consistent(internal, tnpoint, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tnpoint_rtree_ops + DEFAULT FOR TYPE tnpoint USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (tnpoint, stbox), + OPERATOR 1 << (tnpoint, tnpoint), + -- overlaps or left + OPERATOR 2 &< (tnpoint, stbox), + OPERATOR 2 &< (tnpoint, tnpoint), + -- overlaps + OPERATOR 3 && (tnpoint, tstzspan), + OPERATOR 3 && (tnpoint, stbox), + OPERATOR 3 && (tnpoint, tnpoint), + -- overlaps or right + OPERATOR 4 &> (tnpoint, stbox), + OPERATOR 4 &> (tnpoint, tnpoint), + -- strictly right + OPERATOR 5 >> (tnpoint, stbox), + OPERATOR 5 >> (tnpoint, tnpoint), + -- same + OPERATOR 6 ~= (tnpoint, tstzspan), + OPERATOR 6 ~= (tnpoint, stbox), + OPERATOR 6 ~= (tnpoint, tnpoint), + -- contains + OPERATOR 7 @> (tnpoint, tstzspan), + OPERATOR 7 @> (tnpoint, stbox), + OPERATOR 7 @> (tnpoint, tnpoint), + -- contained by + OPERATOR 8 <@ (tnpoint, tstzspan), + OPERATOR 8 <@ (tnpoint, stbox), + OPERATOR 8 <@ (tnpoint, tnpoint), + -- overlaps or below + OPERATOR 9 &<| (tnpoint, stbox), + OPERATOR 9 &<| (tnpoint, tnpoint), + -- strictly below + OPERATOR 10 <<| (tnpoint, stbox), + OPERATOR 10 <<| (tnpoint, tnpoint), + -- strictly above + OPERATOR 11 |>> (tnpoint, stbox), + OPERATOR 11 |>> (tnpoint, tnpoint), + -- overlaps or above + OPERATOR 12 |&> (tnpoint, stbox), + OPERATOR 12 |&> (tnpoint, tnpoint), + -- adjacent + OPERATOR 17 -|- (tnpoint, tstzspan), + OPERATOR 17 -|- (tnpoint, stbox), + OPERATOR 17 -|- (tnpoint, tnpoint), + -- nearest approach distance +-- OPERATOR 25 |=| (tnpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tnpoint, tstzspan), + OPERATOR 28 &<# (tnpoint, stbox), + OPERATOR 28 &<# (tnpoint, tnpoint), + -- strictly before + OPERATOR 29 <<# (tnpoint, tstzspan), + OPERATOR 29 <<# (tnpoint, stbox), + OPERATOR 29 <<# (tnpoint, tnpoint), + -- strictly after + OPERATOR 30 #>> (tnpoint, tstzspan), + OPERATOR 30 #>> (tnpoint, stbox), + OPERATOR 30 #>> (tnpoint, tnpoint), + -- overlaps or after + OPERATOR 31 #&> (tnpoint, tstzspan), + OPERATOR 31 #&> (tnpoint, stbox), + OPERATOR 31 #&> (tnpoint, tnpoint), + -- functions + FUNCTION 1 tnpoint_gist_consistent(internal, tnpoint, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal); +-- FUNCTION 8 gist_tnpoint_distance(internal, tnpoint, smallint, oid, internal), + +/******************************************************************************/ + +CREATE OPERATOR CLASS tnpoint_quadtree_ops + DEFAULT FOR TYPE tnpoint USING spgist AS + -- strictly left + OPERATOR 1 << (tnpoint, stbox), + OPERATOR 1 << (tnpoint, tnpoint), + -- overlaps or left + OPERATOR 2 &< (tnpoint, stbox), + OPERATOR 2 &< (tnpoint, tnpoint), + -- overlaps + OPERATOR 3 && (tnpoint, tstzspan), + OPERATOR 3 && (tnpoint, stbox), + OPERATOR 3 && (tnpoint, tnpoint), + -- overlaps or right + OPERATOR 4 &> (tnpoint, stbox), + OPERATOR 4 &> (tnpoint, tnpoint), + -- strictly right + OPERATOR 5 >> (tnpoint, stbox), + OPERATOR 5 >> (tnpoint, tnpoint), + -- same + OPERATOR 6 ~= (tnpoint, tstzspan), + OPERATOR 6 ~= (tnpoint, stbox), + OPERATOR 6 ~= (tnpoint, tnpoint), + -- contains + OPERATOR 7 @> (tnpoint, tstzspan), + OPERATOR 7 @> (tnpoint, stbox), + OPERATOR 7 @> (tnpoint, tnpoint), + -- contained by + OPERATOR 8 <@ (tnpoint, tstzspan), + OPERATOR 8 <@ (tnpoint, stbox), + OPERATOR 8 <@ (tnpoint, tnpoint), + -- overlaps or below + OPERATOR 9 &<| (tnpoint, stbox), + OPERATOR 9 &<| (tnpoint, tnpoint), + -- strictly below + OPERATOR 10 <<| (tnpoint, stbox), + OPERATOR 10 <<| (tnpoint, tnpoint), + -- strictly above + OPERATOR 11 |>> (tnpoint, stbox), + OPERATOR 11 |>> (tnpoint, tnpoint), + -- overlaps or above + OPERATOR 12 |&> (tnpoint, stbox), + OPERATOR 12 |&> (tnpoint, tnpoint), + -- adjacent + OPERATOR 17 -|- (tnpoint, tstzspan), + OPERATOR 17 -|- (tnpoint, stbox), + OPERATOR 17 -|- (tnpoint, tnpoint), + -- nearest approach distance +-- OPERATOR 25 |=| (tnpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tnpoint, tstzspan), + OPERATOR 28 &<# (tnpoint, stbox), + OPERATOR 28 &<# (tnpoint, tnpoint), + -- strictly before + OPERATOR 29 <<# (tnpoint, tstzspan), + OPERATOR 29 <<# (tnpoint, stbox), + OPERATOR 29 <<# (tnpoint, tnpoint), + -- strictly after + OPERATOR 30 #>> (tnpoint, tstzspan), + OPERATOR 30 #>> (tnpoint, stbox), + OPERATOR 30 #>> (tnpoint, tnpoint), + -- overlaps or after + OPERATOR 31 #&> (tnpoint, tstzspan), + OPERATOR 31 #&> (tnpoint, stbox), + OPERATOR 31 #&> (tnpoint, tnpoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tnpoint_kdtree_ops + FOR TYPE tnpoint USING spgist AS + -- strictly left + OPERATOR 1 << (tnpoint, stbox), + OPERATOR 1 << (tnpoint, tnpoint), + -- overlaps or left + OPERATOR 2 &< (tnpoint, stbox), + OPERATOR 2 &< (tnpoint, tnpoint), + -- overlaps + OPERATOR 3 && (tnpoint, tstzspan), + OPERATOR 3 && (tnpoint, stbox), + OPERATOR 3 && (tnpoint, tnpoint), + -- overlaps or right + OPERATOR 4 &> (tnpoint, stbox), + OPERATOR 4 &> (tnpoint, tnpoint), + -- strictly right + OPERATOR 5 >> (tnpoint, stbox), + OPERATOR 5 >> (tnpoint, tnpoint), + -- same + OPERATOR 6 ~= (tnpoint, tstzspan), + OPERATOR 6 ~= (tnpoint, stbox), + OPERATOR 6 ~= (tnpoint, tnpoint), + -- contains + OPERATOR 7 @> (tnpoint, tstzspan), + OPERATOR 7 @> (tnpoint, stbox), + OPERATOR 7 @> (tnpoint, tnpoint), + -- contained by + OPERATOR 8 <@ (tnpoint, tstzspan), + OPERATOR 8 <@ (tnpoint, stbox), + OPERATOR 8 <@ (tnpoint, tnpoint), + -- overlaps or below + OPERATOR 9 &<| (tnpoint, stbox), + OPERATOR 9 &<| (tnpoint, tnpoint), + -- strictly below + OPERATOR 10 <<| (tnpoint, stbox), + OPERATOR 10 <<| (tnpoint, tnpoint), + -- strictly above + OPERATOR 11 |>> (tnpoint, stbox), + OPERATOR 11 |>> (tnpoint, tnpoint), + -- overlaps or above + OPERATOR 12 |&> (tnpoint, stbox), + OPERATOR 12 |&> (tnpoint, tnpoint), + -- adjacent + OPERATOR 17 -|- (tnpoint, tstzspan), + OPERATOR 17 -|- (tnpoint, stbox), + OPERATOR 17 -|- (tnpoint, tnpoint), + -- nearest approach distance +-- OPERATOR 25 |=| (tnpoint, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tnpoint, tstzspan), + OPERATOR 28 &<# (tnpoint, stbox), + OPERATOR 28 &<# (tnpoint, tnpoint), + -- strictly before + OPERATOR 29 <<# (tnpoint, tstzspan), + OPERATOR 29 <<# (tnpoint, stbox), + OPERATOR 29 <<# (tnpoint, tnpoint), + -- strictly after + OPERATOR 30 #>> (tnpoint, tstzspan), + OPERATOR 30 #>> (tnpoint, stbox), + OPERATOR 30 #>> (tnpoint, tnpoint), + -- overlaps or after + OPERATOR 31 #&> (tnpoint, tstzspan), + OPERATOR 31 #&> (tnpoint, stbox), + OPERATOR 31 #&> (tnpoint, tnpoint), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/CMakeLists.txt new file mode 100644 index 0000000..c67c17e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/npoint/CMakeLists.txt @@ -0,0 +1,24 @@ +# No Postgres version dependant files + +SET(LOCAL_FILES + 081_npoint + 082_npointset + 083_tnpoint + 085_tnpoint_compops + 087_tnpoint_spatialfuncs + 089_tnpoint_topops + 090_tnpoint_posops + 091_tnpoint_routeops + 092_tnpoint_gin + 093_tnpoint_distance + 095_tnpoint_aggfuncs + 098_tnpoint_indexes + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/100_pose.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/100_pose.in.sql new file mode 100644 index 0000000..f5fc22f --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/100_pose.in.sql @@ -0,0 +1,346 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for the static pose type + */ + +CREATE TYPE pose; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION pose_in(cstring) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_in' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pose_out(pose) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Pose_out' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pose_recv(internal) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_recv' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION pose_send(pose) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Pose_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE pose ( + internallength = variable, + input = pose_in, + output = pose_out, + receive = pose_recv, + send = pose_send, + storage = plain, + alignment = double +); + +/***************************************************************************** + * Input/output from (E)WKT, (E)WKB, and HexEWKB + *****************************************************************************/ + +CREATE FUNCTION poseFromText(text) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION poseFromEWKT(text) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION poseFromBinary(bytea) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION poseFromEWKB(bytea) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION poseFromHexEWKB(text) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asText(pose, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Pose_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(pose[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(pose, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Pose_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(pose[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(pose, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Pose_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(pose, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Pose_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(pose, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Pose_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION pose(double precision, double precision, double precision, + srid integer DEFAULT 0) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION pose(double precision, double precision, double precision, + double precision, double precision, double precision, double precision, + srid integer DEFAULT 0) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION pose(geometry, double precision) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_constructor_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION pose(geometry, double precision, double precision, + double precision, double precision) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_constructor_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Conversions + *****************************************************************************/ + +CREATE FUNCTION geometry(pose) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Pose_to_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (pose AS geometry) WITH FUNCTION geometry(pose); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +CREATE FUNCTION point(pose) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Pose_point' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION rotation(pose) + RETURNS float + AS 'MODULE_PATHNAME', 'Pose_rotation' + LANGUAGE C IMMUTABLE STRICT; + +CREATE TYPE quaternion AS ( + W float, + X float, + Y float, + Z float +); + +CREATE FUNCTION orientation(pose) + RETURNS quaternion + AS 'MODULE_PATHNAME', 'Pose_orientation' + LANGUAGE C IMMUTABLE STRICT; + +/***************************************************************************** + * Modification functions + *****************************************************************************/ + +CREATE FUNCTION round(pose, integer DEFAULT 0) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * SRID functions + *****************************************************************************/ + +CREATE FUNCTION SRID(pose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Pose_srid' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION setSRID(pose, integer) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(pose, integer) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(pose, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS pose + AS 'MODULE_PATHNAME', 'Pose_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION pose_same(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = pose_same, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/****************************************************************************** + * Comparisons + ******************************************************************************/ + +CREATE FUNCTION pose_eq(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_ne(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_lt(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_le(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_ge(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_gt(pose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Pose_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_cmp(pose, pose) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Pose_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + PROCEDURE = pose_eq, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = pose_ne, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = pose_lt, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = pose_le, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarlesel, JOIN = scalarlejoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = pose_ge, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargesel, JOIN = scalargejoinsel +); +CREATE OPERATOR > ( + PROCEDURE = pose_gt, + LEFTARG = pose, RIGHTARG = pose, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS pose_btree_ops + DEFAULT FOR TYPE pose USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 pose_cmp(pose, pose); + +/******************************************************************************/ + +CREATE FUNCTION pose_hash(pose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Pose_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION pose_hash_extended(pose, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Pose_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS pose_hash_ops + DEFAULT FOR TYPE pose USING hash AS + OPERATOR 1 = , + FUNCTION 1 pose_hash(pose), + FUNCTION 2 pose_hash_extended(pose, bigint); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/101_poseset.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/101_poseset.in.sql new file mode 100644 index 0000000..6ce5bf0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/101_poseset.in.sql @@ -0,0 +1,529 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for set of circular buffers + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE poseset; + +CREATE FUNCTION poseset_in(cstring) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION poseset_out(poseset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION poseset_recv(internal) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION poseset_send(poseset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE poseset ( + internallength = variable, + input = poseset_in, + output = poseset_out, + receive = poseset_recv, + send = poseset_send, + alignment = double, + storage = extended + -- , analyze = geoset_analyze +); + +/******************************************************************************/ + +-- Input/output in WKT, WKB, and HexWKB representation + +CREATE FUNCTION posesetFromText(text) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION posesetFromEWKT(text) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Spatialset_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION posesetFromBinary(bytea) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION posesetFromEWKB(bytea) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION posesetFromHexWKB(text) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(poseset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(poseset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(poseset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKB(poseset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spatialset_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(poseset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION set(pose[]) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION set(pose) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (pose AS poseset) WITH FUNCTION set(pose); + +CREATE FUNCTION stbox(poseset) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Spatialset_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (poseset AS stbox) WITH FUNCTION stbox(poseset); + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION round(poseset, integer DEFAULT 0) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION memSize(poseset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numValues(poseset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(poseset) + RETURNS pose + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(poseset) + RETURNS pose + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(poseset, integer) + RETURNS pose + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getValues(poseset) + RETURNS pose[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * SRID + ******************************************************************************/ + +CREATE FUNCTION SRID(poseset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spatialset_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(poseset, integer) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Spatialset_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(poseset, integer) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Spatialset_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(poseset, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Spatialset_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation set of values <-> set + ******************************************************************************/ + +CREATE FUNCTION unnest(poseset) + RETURNS SETOF pose + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, pose) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, poseset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION poseset_union_finalfn(internal) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE setUnion(pose) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = poseset_union_finalfn +); +CREATE AGGREGATE setUnion(poseset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = poseset_union_finalfn +); + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION set_eq(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(poseset, poseset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(poseset, poseset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >= + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = > + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = < + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = poseset, RIGHTARG = poseset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <= + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS poseset_btree_ops + DEFAULT FOR TYPE poseset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(poseset, poseset); + +/******************************************************************************/ + +CREATE FUNCTION set_hash(poseset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(poseset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS poseset_hash_ops + DEFAULT FOR TYPE poseset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(poseset), + FUNCTION 2 set_hash_extended(poseset, bigint); + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION set_contains(poseset, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(poseset, poseset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = poseset, RIGHTARG = pose, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = <@ + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_contained(pose, poseset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(poseset, poseset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = pose, RIGHTARG = poseset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = @> + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overlaps(poseset, poseset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = && + -- RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION set_union(pose, poseset) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(poseset, pose) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(poseset, poseset) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = pose, RIGHTARG = poseset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = poseset, RIGHTARG = pose, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION set_minus(pose, poseset) + RETURNS pose + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(poseset, pose) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(poseset, poseset) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = pose, RIGHTARG = poseset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = poseset, RIGHTARG = pose +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = poseset, RIGHTARG = poseset +); + +/*****************************************************************************/ + +CREATE FUNCTION set_intersection(pose, poseset) + RETURNS pose + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(poseset, pose) + RETURNS pose + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(poseset, poseset) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = pose, RIGHTARG = poseset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = poseset, RIGHTARG = pose, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = * +); + +/*****************************************************************************/ + +CREATE FUNCTION set_distance(pose, poseset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(poseset, pose) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(poseset, poseset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = pose, RIGHTARG = poseset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = poseset, RIGHTARG = pose, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = poseset, RIGHTARG = poseset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/102_tpose.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/102_tpose.in.sql new file mode 100644 index 0000000..20fc6d3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/102_tpose.in.sql @@ -0,0 +1,703 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal poses + */ + +CREATE TYPE tpose; + +/****************************************************************************** + * Input/output + ******************************************************************************/ + +CREATE FUNCTION tpose_in(cstring, oid, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tpose_in' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION tpose_out(tpose) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION tpose_recv(internal, oid, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION tpose_send(tpose) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION tpose_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tpose_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tpose ( + internallength = variable, + input = tpose_in, + output = tpose_out, + receive = tpose_recv, + send = tpose_send, + typmod_in = tpose_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tpose(tpose, integer) + RETURNS tpose + AS 'MODULE_PATHNAME','Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tpose AS tpose) WITH FUNCTION tpose(tpose, integer) AS IMPLICIT; + + /***************************************************************************** + * Input/output from (E)WKT, (E)WKB, HexEWKB, and MFJSON representation + *****************************************************************************/ + +CREATE FUNCTION tposeFromText(text) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeFromEWKT(text) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tspatial_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeFromMFJSON(text) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeFromBinary(bytea) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeFromEWKB(bytea) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeFromHexEWKB(text) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asText(tpose, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tpose[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(tpose, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(tpose[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asMFJSON(tpose, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tpose, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(tpose, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(tpose, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION tpose(pose, timestamptz) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tpose(pose, tstzset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tpose(pose, tstzspan, text DEFAULT 'linear') + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tpose(pose, tstzspanset, text DEFAULT 'linear') + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tposeSeq(tpose[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tposeSeqSet(tpose[]) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tposeSeqSetGaps(tpose[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'step') + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/****************************************************************************** + * Conversions + ******************************************************************************/ + +CREATE FUNCTION timeSpan(tpose) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeompoint(tpose) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Tpose_to_tgeompoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tpose AS tstzspan) WITH FUNCTION timeSpan(tpose); +CREATE CAST (tpose AS tgeompoint) WITH FUNCTION tgeompoint(tpose); + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ +-- Specific accessors for temporal poses + +CREATE FUNCTION points(tpose) + RETURNS geomset + AS 'MODULE_PATHNAME', 'Tpose_points' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION rotation(tpose) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tpose_rotation' + LANGUAGE C IMMUTABLE STRICT; + +-- CREATE FUNCTION orientation(tpose) + -- RETURNS quaternion[] + -- AS 'MODULE_PATHNAME', 'Tpose_orientation' + -- LANGUAGE C IMMUTABLE STRICT; + +/******************************************************************************/ +-- Accessors for all temporal types + +CREATE FUNCTION tempSubtype(tpose) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tpose) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(tpose) + RETURNS pose + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getTimestamp(tpose) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- values is a reserved word in SQL +CREATE FUNCTION getValues(tpose) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tpose) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tpose) + RETURNS pose + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tpose) + RETURNS pose + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tpose, int) + RETURNS pose + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tpose, timestamptz) + RETURNS pose + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tpose, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tpose, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tpose) + RETURNS tpose[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tpose) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tpose) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tpose, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tpose) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tpose, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tpose) + RETURNS tpose[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tpose) + RETURNS tpose[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation functions + ******************************************************************************/ + +CREATE FUNCTION tposeInst(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tposeSeq(tpose, text DEFAULT NULL) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tposeSeqSet(tpose, text DEFAULT NULL) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tpose, text) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tpose, integer DEFAULT 0) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tpose[], integer DEFAULT 0) + RETURNS tpose[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftTime(tpose, interval) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tpose, interval) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tpose, interval, interval) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction Functions + *****************************************************************************/ + +CREATE FUNCTION atValues(tpose, pose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tpose, pose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tpose, poseset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tpose, poseset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tpose, timestamptz) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tpose, timestamptz) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tpose, tstzset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tpose, tstzset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tpose, tstzspan) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tpose, tstzspan) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tpose, tstzspanset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tpose, tstzspanset) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tpose, timestamptz, strict bool DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tpose, timestamptz, strict bool DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE TYPE pose_tstzspanset AS ( + value pose, + time tstzspanset +); + +CREATE FUNCTION unnest(tpose) + RETURNS SETOF pose_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stop Function + *****************************************************************************/ + +CREATE FUNCTION stops(tpose, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tpose, tpose, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tpose, tpose, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tpose, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tpose, tstzset, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tpose, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tpose, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION merge(tpose[]) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE time_tpose AS ( + time timestamptz, + temp tpose +); + +CREATE FUNCTION timeSplit(tpose, bin_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_tpose + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tpose, tpose) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tpose, tpose) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS tpose_btree_ops + DEFAULT FOR TYPE tpose USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tpose, tpose); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tpose_hash_ops + DEFAULT FOR TYPE tpose USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tpose); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/104_tpose_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/104_tpose_compops.in.sql new file mode 100644 index 0000000..298da78 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/104_tpose_compops.in.sql @@ -0,0 +1,248 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Ever/always and temporal comparison functions and operators for + * temporal poses + */ + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(pose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_pose_tpose' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(pose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_pose_tpose' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = pose, RIGHTARG = tpose, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = pose, RIGHTARG = tpose, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(pose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(pose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = pose, RIGHTARG = tpose, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = pose, RIGHTARG = tpose, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tpose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_tpose_pose' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tpose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_tpose_pose' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tpose, RIGHTARG = pose, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tpose, RIGHTARG = pose, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tpose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_tpose_pose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tpose, pose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_tpose_pose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tpose, RIGHTARG = pose, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tpose, RIGHTARG = pose, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_temporal' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_temporal' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal equal + *****************************************************************************/ + +CREATE FUNCTION temporal_teq(pose, tpose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tpose, pose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_tpose_pose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tpose, tpose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = pose, RIGHTARG = tpose, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tpose, RIGHTARG = pose, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal not equal + *****************************************************************************/ + +CREATE FUNCTION temporal_tne(pose, tpose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tpose, pose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_tpose_pose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tpose, tpose) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = pose, RIGHTARG = tpose, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tpose, RIGHTARG = pose, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = #<> +); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/105_tpose_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/105_tpose_spatialfuncs.in.sql new file mode 100644 index 0000000..52460d9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/105_tpose_spatialfuncs.in.sql @@ -0,0 +1,84 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial functions for temporal poses + */ + +/***************************************************************************** + * SRID + *****************************************************************************/ + +CREATE FUNCTION SRID(tpose) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(tpose, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(tpose, integer) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(tpose, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * AtGeometry and MinusGeometry + *****************************************************************************/ + +CREATE FUNCTION atGeometry(tpose, geometry) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tpose_at_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusGeometry(tpose, geometry) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tpose_minus_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atStbox(tpose, stbox, bool DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tpose_at_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusStbox(tpose, stbox, bool DEFAULT TRUE) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Tpose_minus_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/108_tpose_topops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/108_tpose_topops.in.sql new file mode 100644 index 0000000..c7df6ef --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/108_tpose_topops.in.sql @@ -0,0 +1,379 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box operators for temporal poses + */ + +/***************************************************************************** + * Temporal pose to stbox + *****************************************************************************/ + +CREATE FUNCTION stbox(pose) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Pose_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(pose, timestamptz) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Pose_timestamptz_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(pose, tstzspan) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Pose_tstzspan_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stbox(tpose) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (pose AS stbox) WITH FUNCTION stbox(pose); +CREATE CAST (tpose AS stbox) WITH FUNCTION stbox(tpose); + +/*****************************************************************************/ + +CREATE FUNCTION expandSpace(tpose, float) + RETURNS stbox + AS 'SELECT @extschema@.expandSpace($1::stbox, $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tpose, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tpose, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = tpose, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contains(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tpose, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tpose, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tpose, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = tpose, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contained(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tpose, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tpose, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tpose, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = tpose, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_overlaps(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tpose, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tpose, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tpose, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = tpose, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_same(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tpose, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tpose, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tpose, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = tpose, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_adjacent(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tpose, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tpose, RIGHTARG = tpose, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/109_tpose_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/109_tpose_posops.in.sql new file mode 100644 index 0000000..2554216 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/109_tpose_posops.in.sql @@ -0,0 +1,601 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for temporal poses + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tpose */ + +CREATE FUNCTION temporal_before(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tpose, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tpose, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tpose, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tpose, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_back, + COMMUTATOR = < ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * tpose + *****************************************************************************/ + +/* tpose op tstzspan */ + +CREATE FUNCTION temporal_before(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tpose, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tpose, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tpose, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tpose, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tpose, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* tpose op stbox */ + +CREATE FUNCTION temporal_left(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tpose, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_back, + COMMUTATOR = '< ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* tpose op tpose */ + +CREATE FUNCTION temporal_left(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_front(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Front_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overfront(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overfront_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_back(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Back_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overback(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overback_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tpose, tpose) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_back, + COMMUTATOR = '< ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overback, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/111_tpose_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/111_tpose_aggfuncs.in.sql new file mode 100644 index 0000000..ae09b4e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/111_tpose_aggfuncs.in.sql @@ -0,0 +1,155 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal poses + */ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tpose) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tpose) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, tpose, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(tpose, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tpose) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tpose_tagg_finalfn(internal) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(tpose) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tpose_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tpose, tpose, + interp text DEFAULT NULL) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(tpose, tpose, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tpose) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tpose, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tpose, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tpose, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tpose, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = tpose, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tpose) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tpose, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/113_tpose_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/113_tpose_distance.in.sql new file mode 100644 index 0000000..88c4417 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/113_tpose_distance.in.sql @@ -0,0 +1,218 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal distance for temporal poses + */ + +CREATE FUNCTION tDistance(geometry(Point), tpose) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_point_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(pose, tpose) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tpose, geometry(Point)) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tpose_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tpose, pose) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tpose_pose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tpose, tpose) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tpose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = geometry, + RIGHTARG = tpose, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = pose, + RIGHTARG = tpose, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tpose, + RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tpose, + RIGHTARG = pose, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tpose, + RIGHTARG = tpose, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant/distance and shortest line functions + *****************************************************************************/ + +CREATE FUNCTION nearestApproachInstant(geometry, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'NAI_geo_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(stbox, tpose) + RETURNS tpose + AS 'SELECT @extschema@.nearestApproachInstant(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(pose, tpose) + RETURNS tpose + AS 'SELECT @extschema@.nearestApproachInstant(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tpose, geometry) + RETURNS tpose + AS 'MODULE_PATHNAME', 'NAI_tpose_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tpose, stbox) + RETURNS tpose + AS 'SELECT @extschema@.nearestApproachInstant($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tpose, pose) + RETURNS tpose + AS 'SELECT @extschema@.nearestApproachInstant($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(tpose, tpose) + RETURNS tpose + AS 'MODULE_PATHNAME', 'NAI_tpose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION nearestApproachDistance(geometry, tpose) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, tpose) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(pose, tpose) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_pose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tpose, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tpose_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tpose, stbox) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tpose, pose) + RETURNS float + AS 'SELECT @extschema@.nearestApproachDistance($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tpose, tpose) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tpose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = tpose, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tpose, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = tpose, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tpose, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = pose, RIGHTARG = tpose, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tpose, RIGHTARG = pose, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tpose, RIGHTARG = tpose, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +/*****************************************************************************/ + +CREATE FUNCTION shortestLine(geometry, tpose) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(stbox, tpose) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(pose, tpose) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine(geometry($1), $2)' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tpose, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tpose_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tpose, stbox) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tpose, pose) + RETURNS geometry + AS 'SELECT @extschema@.shortestLine($1, geometry($2))' + LANGUAGE SQL IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION shortestLine(tpose, tpose) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tpose_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/114_tpose_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/114_tpose_indexes.in.sql new file mode 100644 index 0000000..3e6a1fe --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/114_tpose_indexes.in.sql @@ -0,0 +1,266 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST and SP-GiST indexes for temporal poses + */ + +/******************************************************************************/ + +CREATE FUNCTION tpose_gist_consistent(internal, tpose, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tpose_rtree_ops + DEFAULT FOR TYPE tpose USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (tpose, stbox), + OPERATOR 1 << (tpose, tpose), + -- overlaps or left + OPERATOR 2 &< (tpose, stbox), + OPERATOR 2 &< (tpose, tpose), + -- overlaps + OPERATOR 3 && (tpose, tstzspan), + OPERATOR 3 && (tpose, stbox), + OPERATOR 3 && (tpose, tpose), + -- overlaps or right + OPERATOR 4 &> (tpose, stbox), + OPERATOR 4 &> (tpose, tpose), + -- strictly right + OPERATOR 5 >> (tpose, stbox), + OPERATOR 5 >> (tpose, tpose), + -- same + OPERATOR 6 ~= (tpose, tstzspan), + OPERATOR 6 ~= (tpose, stbox), + OPERATOR 6 ~= (tpose, tpose), + -- contains + OPERATOR 7 @> (tpose, tstzspan), + OPERATOR 7 @> (tpose, stbox), + OPERATOR 7 @> (tpose, tpose), + -- contained by + OPERATOR 8 <@ (tpose, tstzspan), + OPERATOR 8 <@ (tpose, stbox), + OPERATOR 8 <@ (tpose, tpose), + -- overlaps or below + OPERATOR 9 &<| (tpose, stbox), + OPERATOR 9 &<| (tpose, tpose), + -- strictly below + OPERATOR 10 <<| (tpose, stbox), + OPERATOR 10 <<| (tpose, tpose), + -- strictly above + OPERATOR 11 |>> (tpose, stbox), + OPERATOR 11 |>> (tpose, tpose), + -- overlaps or above + OPERATOR 12 |&> (tpose, stbox), + OPERATOR 12 |&> (tpose, tpose), + -- adjacent + OPERATOR 17 -|- (tpose, tstzspan), + OPERATOR 17 -|- (tpose, stbox), + OPERATOR 17 -|- (tpose, tpose), + -- nearest approach distance +-- OPERATOR 25 |=| (tpose, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tpose, tstzspan), + OPERATOR 28 &<# (tpose, stbox), + OPERATOR 28 &<# (tpose, tpose), + -- strictly before + OPERATOR 29 <<# (tpose, tstzspan), + OPERATOR 29 <<# (tpose, stbox), + OPERATOR 29 <<# (tpose, tpose), + -- strictly after + OPERATOR 30 #>> (tpose, tstzspan), + OPERATOR 30 #>> (tpose, stbox), + OPERATOR 30 #>> (tpose, tpose), + -- overlaps or after + OPERATOR 31 #&> (tpose, tstzspan), + OPERATOR 31 #&> (tpose, stbox), + OPERATOR 31 #&> (tpose, tpose), + -- functions + FUNCTION 1 tpose_gist_consistent(internal, tpose, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal); +-- FUNCTION 8 gist_tpose_distance(internal, tpose, smallint, oid, internal), + +/******************************************************************************/ + +CREATE OPERATOR CLASS tpose_quadtree_ops + DEFAULT FOR TYPE tpose USING spgist AS + -- strictly left + OPERATOR 1 << (tpose, stbox), + OPERATOR 1 << (tpose, tpose), + -- overlaps or left + OPERATOR 2 &< (tpose, stbox), + OPERATOR 2 &< (tpose, tpose), + -- overlaps + OPERATOR 3 && (tpose, tstzspan), + OPERATOR 3 && (tpose, stbox), + OPERATOR 3 && (tpose, tpose), + -- overlaps or right + OPERATOR 4 &> (tpose, stbox), + OPERATOR 4 &> (tpose, tpose), + -- strictly right + OPERATOR 5 >> (tpose, stbox), + OPERATOR 5 >> (tpose, tpose), + -- same + OPERATOR 6 ~= (tpose, tstzspan), + OPERATOR 6 ~= (tpose, stbox), + OPERATOR 6 ~= (tpose, tpose), + -- contains + OPERATOR 7 @> (tpose, tstzspan), + OPERATOR 7 @> (tpose, stbox), + OPERATOR 7 @> (tpose, tpose), + -- contained by + OPERATOR 8 <@ (tpose, tstzspan), + OPERATOR 8 <@ (tpose, stbox), + OPERATOR 8 <@ (tpose, tpose), + -- overlaps or below + OPERATOR 9 &<| (tpose, stbox), + OPERATOR 9 &<| (tpose, tpose), + -- strictly below + OPERATOR 10 <<| (tpose, stbox), + OPERATOR 10 <<| (tpose, tpose), + -- strictly above + OPERATOR 11 |>> (tpose, stbox), + OPERATOR 11 |>> (tpose, tpose), + -- overlaps or above + OPERATOR 12 |&> (tpose, stbox), + OPERATOR 12 |&> (tpose, tpose), + -- adjacent + OPERATOR 17 -|- (tpose, tstzspan), + OPERATOR 17 -|- (tpose, stbox), + OPERATOR 17 -|- (tpose, tpose), + -- nearest approach distance +-- OPERATOR 25 |=| (tpose, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tpose, tstzspan), + OPERATOR 28 &<# (tpose, stbox), + OPERATOR 28 &<# (tpose, tpose), + -- strictly before + OPERATOR 29 <<# (tpose, tstzspan), + OPERATOR 29 <<# (tpose, stbox), + OPERATOR 29 <<# (tpose, tpose), + -- strictly after + OPERATOR 30 #>> (tpose, tstzspan), + OPERATOR 30 #>> (tpose, stbox), + OPERATOR 30 #>> (tpose, tpose), + -- overlaps or after + OPERATOR 31 #&> (tpose, tstzspan), + OPERATOR 31 #&> (tpose, stbox), + OPERATOR 31 #&> (tpose, tpose), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tpose_kdtree_ops + FOR TYPE tpose USING spgist AS + -- strictly left + OPERATOR 1 << (tpose, stbox), + OPERATOR 1 << (tpose, tpose), + -- overlaps or left + OPERATOR 2 &< (tpose, stbox), + OPERATOR 2 &< (tpose, tpose), + -- overlaps + OPERATOR 3 && (tpose, tstzspan), + OPERATOR 3 && (tpose, stbox), + OPERATOR 3 && (tpose, tpose), + -- overlaps or right + OPERATOR 4 &> (tpose, stbox), + OPERATOR 4 &> (tpose, tpose), + -- strictly right + OPERATOR 5 >> (tpose, stbox), + OPERATOR 5 >> (tpose, tpose), + -- same + OPERATOR 6 ~= (tpose, tstzspan), + OPERATOR 6 ~= (tpose, stbox), + OPERATOR 6 ~= (tpose, tpose), + -- contains + OPERATOR 7 @> (tpose, tstzspan), + OPERATOR 7 @> (tpose, stbox), + OPERATOR 7 @> (tpose, tpose), + -- contained by + OPERATOR 8 <@ (tpose, tstzspan), + OPERATOR 8 <@ (tpose, stbox), + OPERATOR 8 <@ (tpose, tpose), + -- overlaps or below + OPERATOR 9 &<| (tpose, stbox), + OPERATOR 9 &<| (tpose, tpose), + -- strictly below + OPERATOR 10 <<| (tpose, stbox), + OPERATOR 10 <<| (tpose, tpose), + -- strictly above + OPERATOR 11 |>> (tpose, stbox), + OPERATOR 11 |>> (tpose, tpose), + -- overlaps or above + OPERATOR 12 |&> (tpose, stbox), + OPERATOR 12 |&> (tpose, tpose), + -- adjacent + OPERATOR 17 -|- (tpose, tstzspan), + OPERATOR 17 -|- (tpose, stbox), + OPERATOR 17 -|- (tpose, tpose), + -- nearest approach distance +-- OPERATOR 25 |=| (tpose, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tpose, tstzspan), + OPERATOR 28 &<# (tpose, stbox), + OPERATOR 28 &<# (tpose, tpose), + -- strictly before + OPERATOR 29 <<# (tpose, tstzspan), + OPERATOR 29 <<# (tpose, stbox), + OPERATOR 29 <<# (tpose, tpose), + -- strictly after + OPERATOR 30 #>> (tpose, tstzspan), + OPERATOR 30 #>> (tpose, stbox), + OPERATOR 30 #>> (tpose, tpose), + -- overlaps or after + OPERATOR 31 #&> (tpose, tstzspan), + OPERATOR 31 #&> (tpose, stbox), + OPERATOR 31 #&> (tpose, tpose), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/CMakeLists.txt new file mode 100644 index 0000000..a59f998 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/pose/CMakeLists.txt @@ -0,0 +1,20 @@ +SET(LOCAL_FILES + 100_pose + 101_poseset + 102_tpose + 104_tpose_compops + 105_tpose_spatialfuncs + 108_tpose_topops + 109_tpose_posops + 111_tpose_aggfuncs + 113_tpose_distance + 114_tpose_indexes + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/122_trgeo.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/122_trgeo.in.sql new file mode 100644 index 0000000..aa5be6e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/122_trgeo.in.sql @@ -0,0 +1,704 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal rigid geometries + */ + +CREATE TYPE trgeometry; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION trgeometry_in(cstring, oid, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_in' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION trgeometry_out(trgeometry) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Trgeometry_out' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION trgeometry_recv(internal) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_recv' + LANGUAGE C IMMUTABLE STRICT; +CREATE FUNCTION trgeometry_send(trgeometry) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Trgeometry_send' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION trgeo_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Trgeometry_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE trgeometry ( + internallength = variable, + input = trgeometry_in, + output = trgeometry_out, + receive = trgeometry_recv, + send = trgeometry_send, + typmod_in = trgeo_typmod_in, + typmod_out = tspatial_typmod_out, + storage = extended, + alignment = double, + analyze = tspatial_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION trgeometry(trgeometry, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME','Tspatial_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (trgeometry AS trgeometry) WITH FUNCTION trgeometry(trgeometry, integer) AS IMPLICIT; + +/***************************************************************************** + * Input/output from (E)WKT, (E)WKB, HexEWKB, and MFJSON representation + *****************************************************************************/ + +CREATE FUNCTION trgeometryFromText(text) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometryFromEWKT(text) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_from_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometryFromMFJSON(text) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometryFromBinary(bytea) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometryFromEWKB(bytea) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometryFromHexEWKB(text) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION asText(trgeometry, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Trgeometry_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(trgeometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKT(trgeometry, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Trgeometry_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asEWKT(trgeometry[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Spatialarr_as_ewkt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asMFJSON(trgeometry, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(trgeometry, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asEWKB(trgeometry, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tspatial_as_ewkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexEWKB(trgeometry, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructors + ******************************************************************************/ + +CREATE FUNCTION trgeometry(geometry, pose, timestamptz) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_inst_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometrySeq(trgeometry[], text DEFAULT 'linear', + lower_inc boolean DEFAULT true, upper_inc boolean DEFAULT true) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_seq_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trgeometrySeqSet(trgeometry[]) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_seqset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION trgeometrySeqSetGaps(trgeometry[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_seqset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION trgeometry(geometry, tpose) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION timeSpan(trgeometry) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (trgeometry AS tstzspan) WITH FUNCTION timeSpan(trgeometry); + +CREATE FUNCTION tpose(trgeometry) + RETURNS tpose + AS 'MODULE_PATHNAME', 'Trgeometry_to_tpose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tgeompoint(trgeometry) + RETURNS tgeompoint + AS 'MODULE_PATHNAME', 'Trgeometry_to_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (trgeometry AS tpose) WITH FUNCTION tpose(trgeometry); +CREATE CAST (trgeometry AS tgeompoint) WITH FUNCTION tgeompoint(trgeometry); + +CREATE FUNCTION stbox(trgeometry) + RETURNS stbox + AS 'MODULE_PATHNAME', 'Tspatial_to_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (trgeometry AS stbox) WITH FUNCTION stbox(trgeometry); + +CREATE FUNCTION geometry(trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Trgeometry_to_geom' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (trgeometry AS geometry) WITH FUNCTION geometry(trgeometry); + +/****************************************************************************** + * Accessor Functions + ******************************************************************************/ + +/******************************************************************************/ + +CREATE FUNCTION tempSubtype(trgeometry) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(trgeometry) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(trgeometry) + RETURNS int + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- value is a reserved word in SQL +CREATE FUNCTION getValue(trgeometry) + RETURNS pose + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getTimestamp(trgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getValues(trgeometry) + RETURNS poseset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(trgeometry) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Trgeometry_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Trgeometry_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(trgeometry, int) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Trgeometry_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(trgeometry, timestamptz) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Trgeometry_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(trgeometry, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(trgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(trgeometry, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(trgeometry) + RETURNS trgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(trgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(trgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(trgeometry) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(trgeometry, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(trgeometry) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(trgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(trgeometry, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(trgeometry) + RETURNS trgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(trgeometry) + RETURNS trgeometry[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation functions + ******************************************************************************/ + +CREATE FUNCTION trgeometryInst(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION trgeometrySeq(trgeometry, text DEFAULT NULL) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION trgeometrySeqSet(trgeometry, text DEFAULT NULL) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Trgeometry_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(trgeometry, text) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(trgeometry, integer DEFAULT 0) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(trgeometry[], integer DEFAULT 0) + RETURNS trgeometry[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftTime(trgeometry, interval) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(trgeometry, interval) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(trgeometry, interval, interval) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION tprecision(trgeometry, duration interval, +-- origin timestamptz DEFAULT '2000-01-03') +-- RETURNS trgeometry +-- AS 'MODULE_PATHNAME', 'Temporal_tprecision' +-- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION tsample(trgeometry, duration interval, +-- origin timestamptz DEFAULT '2000-01-03') +-- RETURNS trgeometry +-- AS 'MODULE_PATHNAME', 'Temporal_tsample' +-- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction Functions + *****************************************************************************/ + +-- CREATE FUNCTION atValues(trgeometry, geometry) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Temporal_at_value' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION minusValues(trgeometry, geometry) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Temporal_minus_value' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION atValues(trgeometry, geomset) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Temporal_at_values' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION minusValues(trgeometry, geomset) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Temporal_minus_values' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(trgeometry, timestamptz) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(trgeometry, timestamptz) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(trgeometry, tstzset) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(trgeometry, tstzset) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(trgeometry, tstzspan) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(trgeometry, tstzspan) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(trgeometry, tstzspanset) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(trgeometry, tstzspanset) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(trgeometry, timestamptz, strict bool DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(trgeometry, timestamptz, strict bool DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Unnest Function + *****************************************************************************/ + +CREATE FUNCTION unnest(trgeometry) + RETURNS SETOF geom_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stops Function + *****************************************************************************/ + +CREATE FUNCTION stops(trgeometry, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(trgeometry, trgeometry, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(trgeometry, trgeometry, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(trgeometry, timestamptz, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(trgeometry, tstzset, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(trgeometry, tstzspan, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(trgeometry, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION merge(trgeometry[]) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Multidimensional tiling + ******************************************************************************/ + +CREATE TYPE time_trgeometry AS ( + time timestamptz, + temp trgeometry +); + +CREATE FUNCTION timeSplit(trgeometry, bucket_width interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS setof time_trgeometry + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(trgeometry, trgeometry) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(trgeometry, trgeometry) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = scalargtsel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS trgeometry_btree_ops + DEFAULT FOR TYPE trgeometry USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(trgeometry, trgeometry); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(trgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS trgeometry_hash_ops + DEFAULT FOR TYPE trgeometry USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(trgeometry); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/124_trgeo_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/124_trgeo_compops.in.sql new file mode 100644 index 0000000..9a95c4c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/124_trgeo_compops.in.sql @@ -0,0 +1,247 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Ever, always, and temporal comparisons for temporal rigid geometries + */ + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(geometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_geo_trgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(geometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_geo_trgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = geometry, RIGHTARG = trgeometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = geometry, RIGHTARG = trgeometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(geometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(geometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = geometry, RIGHTARG = trgeometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = geometry, RIGHTARG = trgeometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(trgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_trgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(trgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_trgeo_geo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = trgeometry, RIGHTARG = geometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = trgeometry, RIGHTARG = geometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(trgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(trgeometry, geometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = trgeometry, RIGHTARG = geometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = trgeometry, RIGHTARG = geometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_trgeo_trgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_trgeo_trgeo' + SUPPORT tspatial_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION ever_ne(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Temporal equal + *****************************************************************************/ + +CREATE FUNCTION temporal_teq(geometry, trgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(trgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(trgeometry, trgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = geometry, RIGHTARG = trgeometry, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = trgeometry, RIGHTARG = geometry, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal not equal + *****************************************************************************/ + +CREATE FUNCTION temporal_tne(geometry, trgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(trgeometry, geometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(trgeometry, trgeometry) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = geometry, RIGHTARG = trgeometry, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = trgeometry, RIGHTARG = geometry, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = #<> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/125_trgeo_spatialfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/125_trgeo_spatialfuncs.in.sql new file mode 100644 index 0000000..5acd445 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/125_trgeo_spatialfuncs.in.sql @@ -0,0 +1,84 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Spatial functions for temporal poses + */ + +/***************************************************************************** + * SRID + *****************************************************************************/ + +CREATE FUNCTION SRID(trgeometry) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tspatial_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION setSRID(trgeometry, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Tspatial_set_srid' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transform(trgeometry, integer) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Tspatial_transform' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION transformPipeline(trgeometry, text, srid integer DEFAULT 0, + is_forward boolean DEFAULT true) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Tspatial_transform_pipeline' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * AtGeometry and MinusGeometry + *****************************************************************************/ + +-- CREATE FUNCTION atGeometry(trgeometry, geometry) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Trgeo_at_geom' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION minusGeometry(trgeometry, geometry) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Trgeo_minus_geom' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION atStbox(trgeometry, stbox, bool DEFAULT TRUE) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Trgeo_at_stbox' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- CREATE FUNCTION minusStbox(trgeometry, stbox, bool DEFAULT TRUE) + -- RETURNS trgeometry + -- AS 'MODULE_PATHNAME', 'Trgeo_minus_stbox' + -- LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/128_trgeo_topops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/128_trgeo_topops.in.sql new file mode 100644 index 0000000..dc35d3e --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/128_trgeo_topops.in.sql @@ -0,0 +1,345 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box topological operators for temporal rigid geometries + */ + +/***************************************************************************** + * Contains + *****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = trgeometry, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = trgeometry, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = stbox, RIGHTARG = trgeometry, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contains(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = trgeometry, RIGHTARG = stbox, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = <@, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Contained + *****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = trgeometry, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = trgeometry, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = stbox, RIGHTARG = trgeometry, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_contained(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = trgeometry, RIGHTARG = stbox, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = @>, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Overlaps + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = trgeometry, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = trgeometry, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = stbox, RIGHTARG = trgeometry, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_overlaps(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = trgeometry, RIGHTARG = stbox, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = &&, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * Same + *****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = trgeometry, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = trgeometry, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = stbox, RIGHTARG = trgeometry, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_same(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = trgeometry, RIGHTARG = stbox, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = ~=, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * adjacent + *****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = trgeometry, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = trgeometry, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = stbox, RIGHTARG = trgeometry, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +CREATE FUNCTION temporal_adjacent(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = trgeometry, RIGHTARG = stbox, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = -|-, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/129_trgeo_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/129_trgeo_posops.in.sql new file mode 100644 index 0000000..dc3dd46 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/129_trgeo_posops.in.sql @@ -0,0 +1,487 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding box relative position operators for temporal rigid geomtries + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op trgeometry */ + +CREATE FUNCTION temporal_before(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = trgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = trgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = trgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = trgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * stbox + *****************************************************************************/ + +CREATE FUNCTION temporal_left(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(stbox, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_stbox_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/***************************************************************************** + * trgeometry + *****************************************************************************/ + +/* trgeometry op tstzspan */ + +CREATE FUNCTION temporal_before(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(trgeometry, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = trgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = trgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = trgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = trgeometry, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* trgeometry op stbox */ + +CREATE FUNCTION temporal_left(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(trgeometry, stbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ + +/* trgeometry op trgeometry */ + +CREATE FUNCTION temporal_left(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_below(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Below_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbelow(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbelow_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_above(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Above_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overabove(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overabove_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(trgeometry, trgeometry) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tspatial_tspatial' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_left, + COMMUTATOR = '>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overleft, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_right, + COMMUTATOR = '<<', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overright, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<| ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_below, + COMMUTATOR = '|>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<| ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overbelow, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |>> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_above, + COMMUTATOR = '<<|', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR |&> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overabove, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_before, + COMMUTATOR = '#>>', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overbefore, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_after, + COMMUTATOR = '<<#', + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = temporal_overafter, + RESTRICT = tspatial_sel, JOIN = tspatial_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/131_trgeo_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/131_trgeo_aggfuncs.in.sql new file mode 100644 index 0000000..4d19a73 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/131_trgeo_aggfuncs.in.sql @@ -0,0 +1,155 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for temporal rigid geometries + */ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, trgeometry) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(trgeometry) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION wcount_transfn(internal, trgeometry, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wcount(trgeometry, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, trgeometry) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION trgeometry_tagg_finalfn(internal) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE merge(trgeometry) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = trgeometry_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append tinstant aggregate functions + *****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(trgeometry, trgeometry, + interp text DEFAULT NULL) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tinst_transfn(trgeometry, trgeometry, + interp text DEFAULT NULL, maxdist float DEFAULT NULL, + maxt interval DEFAULT NULL) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(trgeometry) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = trgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(trgeometry, text) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = trgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(trgeometry, text, float, interval) ( + SFUNC = temporal_app_tinst_transfn, + STYPE = trgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(trgeometry) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = trgeometry, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_distance.in.sql new file mode 100644 index 0000000..8f83797 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_distance.in.sql @@ -0,0 +1,200 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal rigid geometries + */ + +/***************************************************************************** + * Distance functions + *****************************************************************************/ + +CREATE FUNCTION tdistance(trgeometry, geometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(geometry, trgeometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(trgeometry, tgeompoint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_trgeo_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(tgeompoint, trgeometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tpoint_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tdistance(trgeometry, trgeometry) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = trgeometry, RIGHTARG = geometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = geometry, RIGHTARG = trgeometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = trgeometry, RIGHTARG = tgeompoint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = tgeompoint, RIGHTARG = trgeometry, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tdistance, + LEFTARG = trgeometry, RIGHTARG = trgeometry, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach instant/distance and shortest line functions + *****************************************************************************/ + +CREATE FUNCTION nearestApproachInstant(trgeometry, geometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'NAI_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(geometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'NAI_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(trgeometry, tgeompoint) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'NAI_trgeo_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +/* TODO: Maybe change output type here. + * Currently we return a trgeometry instant + * even if the left argument is a tgeompoint */ +CREATE FUNCTION nearestApproachInstant(tgeompoint, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'NAI_tpoint_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachInstant(trgeometry, trgeometry) + RETURNS trgeometry + AS 'MODULE_PATHNAME', 'NAI_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION nearestApproachDistance(trgeometry, geometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(geometry, trgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(trgeometry, stbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_trgeo_stbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(stbox, trgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_stbox_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(trgeometry, tgeompoint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_trgeo_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tgeompoint, trgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tpoint_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(trgeometry, trgeometry) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + LEFTARG = trgeometry, RIGHTARG = geometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = geometry, RIGHTARG = trgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = trgeometry, RIGHTARG = stbox, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = stbox, RIGHTARG = trgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = trgeometry, RIGHTARG = tgeompoint, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = tgeompoint, RIGHTARG = trgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); +CREATE OPERATOR |=| ( + LEFTARG = trgeometry, RIGHTARG = trgeometry, + PROCEDURE = nearestApproachDistance, + COMMUTATOR = '|=|' +); + +CREATE FUNCTION shortestLine(trgeometry, geometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_trgeo_geo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(geometry, trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_geo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(trgeometry, tgeompoint) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_trgeo_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(tgeompoint, trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_tpoint_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shortestLine(trgeometry, trgeometry) + RETURNS geometry + AS 'MODULE_PATHNAME', 'Shortestline_trgeo_trgeo' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_vclip.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_vclip.in.sql new file mode 100644 index 0000000..51d92d0 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/133_trgeo_vclip.in.sql @@ -0,0 +1,69 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.  + * + *****************************************************************************/ + +/** + * @file + * @brief V-Clip distance functions for temporal rigid geometries + */ + +/***************************************************************************** + * V-clip functions + *****************************************************************************/ + +CREATE FUNCTION v_clip_poly_point(geometry(Polygon), geometry(Point)) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_poly_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION v_clip_poly_poly(geometry(Polygon), geometry(Polygon)) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_poly_poly' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION v_clip_tpoly_point(trgeometry, geometry(Point), timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_tpoly_point' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION v_clip_tpoly_poly(trgeometry, geometry(Polygon), timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_tpoly_poly' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION v_clip_tpoly_tpoint(trgeometry, tgeompoint, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_tpoly_tpoint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION v_clip_tpoly_tpoly(trgeometry, trgeometry, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'VClip_tpoly_tpoly' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/134_trgeo_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/134_trgeo_indexes.in.sql new file mode 100644 index 0000000..38e14b2 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/134_trgeo_indexes.in.sql @@ -0,0 +1,266 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST and SP-GiST indexes for temporal rigid geometries + */ + +/******************************************************************************/ + +CREATE FUNCTION trgeometry_gist_consistent(internal, trgeometry, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Stbox_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS trgeometry_rtree_ops + DEFAULT FOR TYPE trgeometry USING gist AS + STORAGE stbox, + -- strictly left + OPERATOR 1 << (trgeometry, stbox), + OPERATOR 1 << (trgeometry, trgeometry), + -- overlaps or left + OPERATOR 2 &< (trgeometry, stbox), + OPERATOR 2 &< (trgeometry, trgeometry), + -- overlaps + OPERATOR 3 && (trgeometry, tstzspan), + OPERATOR 3 && (trgeometry, stbox), + OPERATOR 3 && (trgeometry, trgeometry), + -- overlaps or right + OPERATOR 4 &> (trgeometry, stbox), + OPERATOR 4 &> (trgeometry, trgeometry), + -- strictly right + OPERATOR 5 >> (trgeometry, stbox), + OPERATOR 5 >> (trgeometry, trgeometry), + -- same + OPERATOR 6 ~= (trgeometry, tstzspan), + OPERATOR 6 ~= (trgeometry, stbox), + OPERATOR 6 ~= (trgeometry, trgeometry), + -- contains + OPERATOR 7 @> (trgeometry, tstzspan), + OPERATOR 7 @> (trgeometry, stbox), + OPERATOR 7 @> (trgeometry, trgeometry), + -- contained by + OPERATOR 8 <@ (trgeometry, tstzspan), + OPERATOR 8 <@ (trgeometry, stbox), + OPERATOR 8 <@ (trgeometry, trgeometry), + -- overlaps or below + OPERATOR 9 &<| (trgeometry, stbox), + OPERATOR 9 &<| (trgeometry, trgeometry), + -- strictly below + OPERATOR 10 <<| (trgeometry, stbox), + OPERATOR 10 <<| (trgeometry, trgeometry), + -- strictly above + OPERATOR 11 |>> (trgeometry, stbox), + OPERATOR 11 |>> (trgeometry, trgeometry), + -- overlaps or above + OPERATOR 12 |&> (trgeometry, stbox), + OPERATOR 12 |&> (trgeometry, trgeometry), + -- adjacent + OPERATOR 17 -|- (trgeometry, tstzspan), + OPERATOR 17 -|- (trgeometry, stbox), + OPERATOR 17 -|- (trgeometry, trgeometry), + -- nearest approach distance +-- OPERATOR 25 |=| (trgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (trgeometry, tstzspan), + OPERATOR 28 &<# (trgeometry, stbox), + OPERATOR 28 &<# (trgeometry, trgeometry), + -- strictly before + OPERATOR 29 <<# (trgeometry, tstzspan), + OPERATOR 29 <<# (trgeometry, stbox), + OPERATOR 29 <<# (trgeometry, trgeometry), + -- strictly after + OPERATOR 30 #>> (trgeometry, tstzspan), + OPERATOR 30 #>> (trgeometry, stbox), + OPERATOR 30 #>> (trgeometry, trgeometry), + -- overlaps or after + OPERATOR 31 #&> (trgeometry, tstzspan), + OPERATOR 31 #&> (trgeometry, stbox), + OPERATOR 31 #&> (trgeometry, trgeometry), + -- functions + FUNCTION 1 trgeometry_gist_consistent(internal, trgeometry, smallint, oid, internal), + FUNCTION 2 stbox_gist_union(internal, internal), + FUNCTION 3 tspatial_gist_compress(internal), + FUNCTION 5 stbox_gist_penalty(internal, internal, internal), + FUNCTION 6 stbox_gist_picksplit(internal, internal), + FUNCTION 7 stbox_gist_same(stbox, stbox, internal); +-- FUNCTION 8 gist_trgeometry_distance(internal, trgeometry, smallint, oid, internal), + +/******************************************************************************/ + +CREATE OPERATOR CLASS trgeometry_quadtree_ops + DEFAULT FOR TYPE trgeometry USING spgist AS + -- strictly left + OPERATOR 1 << (trgeometry, stbox), + OPERATOR 1 << (trgeometry, trgeometry), + -- overlaps or left + OPERATOR 2 &< (trgeometry, stbox), + OPERATOR 2 &< (trgeometry, trgeometry), + -- overlaps + OPERATOR 3 && (trgeometry, tstzspan), + OPERATOR 3 && (trgeometry, stbox), + OPERATOR 3 && (trgeometry, trgeometry), + -- overlaps or right + OPERATOR 4 &> (trgeometry, stbox), + OPERATOR 4 &> (trgeometry, trgeometry), + -- strictly right + OPERATOR 5 >> (trgeometry, stbox), + OPERATOR 5 >> (trgeometry, trgeometry), + -- same + OPERATOR 6 ~= (trgeometry, tstzspan), + OPERATOR 6 ~= (trgeometry, stbox), + OPERATOR 6 ~= (trgeometry, trgeometry), + -- contains + OPERATOR 7 @> (trgeometry, tstzspan), + OPERATOR 7 @> (trgeometry, stbox), + OPERATOR 7 @> (trgeometry, trgeometry), + -- contained by + OPERATOR 8 <@ (trgeometry, tstzspan), + OPERATOR 8 <@ (trgeometry, stbox), + OPERATOR 8 <@ (trgeometry, trgeometry), + -- overlaps or below + OPERATOR 9 &<| (trgeometry, stbox), + OPERATOR 9 &<| (trgeometry, trgeometry), + -- strictly below + OPERATOR 10 <<| (trgeometry, stbox), + OPERATOR 10 <<| (trgeometry, trgeometry), + -- strictly above + OPERATOR 11 |>> (trgeometry, stbox), + OPERATOR 11 |>> (trgeometry, trgeometry), + -- overlaps or above + OPERATOR 12 |&> (trgeometry, stbox), + OPERATOR 12 |&> (trgeometry, trgeometry), + -- adjacent + OPERATOR 17 -|- (trgeometry, tstzspan), + OPERATOR 17 -|- (trgeometry, stbox), + OPERATOR 17 -|- (trgeometry, trgeometry), + -- nearest approach distance +-- OPERATOR 25 |=| (trgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (trgeometry, tstzspan), + OPERATOR 28 &<# (trgeometry, stbox), + OPERATOR 28 &<# (trgeometry, trgeometry), + -- strictly before + OPERATOR 29 <<# (trgeometry, tstzspan), + OPERATOR 29 <<# (trgeometry, stbox), + OPERATOR 29 <<# (trgeometry, trgeometry), + -- strictly after + OPERATOR 30 #>> (trgeometry, tstzspan), + OPERATOR 30 #>> (trgeometry, stbox), + OPERATOR 30 #>> (trgeometry, trgeometry), + -- overlaps or after + OPERATOR 31 #&> (trgeometry, tstzspan), + OPERATOR 31 #&> (trgeometry, stbox), + OPERATOR 31 #&> (trgeometry, trgeometry), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_quadtree_choose(internal, internal), + FUNCTION 3 stbox_quadtree_picksplit(internal, internal), + FUNCTION 4 stbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS trgeometry_kdtree_ops + FOR TYPE trgeometry USING spgist AS + -- strictly left + OPERATOR 1 << (trgeometry, stbox), + OPERATOR 1 << (trgeometry, trgeometry), + -- overlaps or left + OPERATOR 2 &< (trgeometry, stbox), + OPERATOR 2 &< (trgeometry, trgeometry), + -- overlaps + OPERATOR 3 && (trgeometry, tstzspan), + OPERATOR 3 && (trgeometry, stbox), + OPERATOR 3 && (trgeometry, trgeometry), + -- overlaps or right + OPERATOR 4 &> (trgeometry, stbox), + OPERATOR 4 &> (trgeometry, trgeometry), + -- strictly right + OPERATOR 5 >> (trgeometry, stbox), + OPERATOR 5 >> (trgeometry, trgeometry), + -- same + OPERATOR 6 ~= (trgeometry, tstzspan), + OPERATOR 6 ~= (trgeometry, stbox), + OPERATOR 6 ~= (trgeometry, trgeometry), + -- contains + OPERATOR 7 @> (trgeometry, tstzspan), + OPERATOR 7 @> (trgeometry, stbox), + OPERATOR 7 @> (trgeometry, trgeometry), + -- contained by + OPERATOR 8 <@ (trgeometry, tstzspan), + OPERATOR 8 <@ (trgeometry, stbox), + OPERATOR 8 <@ (trgeometry, trgeometry), + -- overlaps or below + OPERATOR 9 &<| (trgeometry, stbox), + OPERATOR 9 &<| (trgeometry, trgeometry), + -- strictly below + OPERATOR 10 <<| (trgeometry, stbox), + OPERATOR 10 <<| (trgeometry, trgeometry), + -- strictly above + OPERATOR 11 |>> (trgeometry, stbox), + OPERATOR 11 |>> (trgeometry, trgeometry), + -- overlaps or above + OPERATOR 12 |&> (trgeometry, stbox), + OPERATOR 12 |&> (trgeometry, trgeometry), + -- adjacent + OPERATOR 17 -|- (trgeometry, tstzspan), + OPERATOR 17 -|- (trgeometry, stbox), + OPERATOR 17 -|- (trgeometry, trgeometry), + -- nearest approach distance +-- OPERATOR 25 |=| (trgeometry, stbox) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (trgeometry, tstzspan), + OPERATOR 28 &<# (trgeometry, stbox), + OPERATOR 28 &<# (trgeometry, trgeometry), + -- strictly before + OPERATOR 29 <<# (trgeometry, tstzspan), + OPERATOR 29 <<# (trgeometry, stbox), + OPERATOR 29 <<# (trgeometry, trgeometry), + -- strictly after + OPERATOR 30 #>> (trgeometry, tstzspan), + OPERATOR 30 #>> (trgeometry, stbox), + OPERATOR 30 #>> (trgeometry, trgeometry), + -- overlaps or after + OPERATOR 31 #&> (trgeometry, tstzspan), + OPERATOR 31 #&> (trgeometry, stbox), + OPERATOR 31 #&> (trgeometry, trgeometry), + -- functions + FUNCTION 1 stbox_spgist_config(internal, internal), + FUNCTION 2 stbox_kdtree_choose(internal, internal), + FUNCTION 3 stbox_kdtree_picksplit(internal, internal), + FUNCTION 4 stbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 stbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tspatial_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/CMakeLists.txt new file mode 100644 index 0000000..cf0fa19 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/rgeo/CMakeLists.txt @@ -0,0 +1,20 @@ +# No Postgres version dependant files + +SET(LOCAL_FILES + 122_trgeo + 124_trgeo_compops + 125_trgeo_spatialfuncs + 128_trgeo_topops + 129_trgeo_posops + 133_trgeo_distance + 133_trgeo_vclip + 134_trgeo_indexes + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/001_set.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/001_set.in.sql new file mode 100644 index 0000000..90a96d3 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/001_set.in.sql @@ -0,0 +1,1446 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for sets of values + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE intset; +CREATE TYPE bigintset; +CREATE TYPE floatset; +CREATE TYPE textset; +CREATE TYPE dateset; +CREATE TYPE tstzset; + +CREATE FUNCTION intset_in(cstring) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intset_out(intset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intset_recv(internal) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intset_send(intset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION bigintset_in(cstring) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintset_out(bigintset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintset_recv(internal) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintset_send(bigintset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floatset_in(cstring) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatset_out(floatset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatset_recv(internal) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatset_send(floatset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION textset_in(cstring) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textset_out(textset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textset_recv(internal) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textset_send(textset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dateset_in(cstring) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dateset_out(dateset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dateset_recv(internal) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dateset_send(dateset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tstzset_in(cstring) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzset_out(tstzset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Set_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzset_recv(internal) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzset_send(tstzset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_analyze(internal) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_analyze' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE intset ( + internallength = variable, + input = intset_in, + output = intset_out, + receive = intset_recv, + send = intset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); + +CREATE TYPE bigintset ( + internallength = variable, + input = bigintset_in, + output = bigintset_out, + receive = bigintset_recv, + send = bigintset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); + +CREATE TYPE floatset ( + internallength = variable, + input = floatset_in, + output = floatset_out, + receive = floatset_recv, + send = floatset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); + +CREATE TYPE textset ( + internallength = variable, + input = textset_in, + output = textset_out, + receive = textset_recv, + send = textset_send, + alignment = double, + storage = extended +); + +CREATE TYPE dateset ( + internallength = variable, + input = dateset_in, + output = dateset_out, + receive = dateset_recv, + send = dateset_send, + alignment = double, + storage = extended +); + +CREATE TYPE tstzset ( + internallength = variable, + input = tstzset_in, + output = tstzset_out, + receive = tstzset_recv, + send = tstzset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); + +/******************************************************************************/ + +-- Input/output in WKT, WKB, and HexWKB representation + +CREATE FUNCTION intsetFromBinary(bytea) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintsetFromBinary(bytea) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatsetFromBinary(bytea) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textsetFromBinary(bytea) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datesetFromBinary(bytea) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzsetFromBinary(bytea) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intsetFromHexWKB(text) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintsetFromHexWKB(text) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatsetFromHexWKB(text) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textsetFromHexWKB(text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datesetFromHexWKB(text) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzsetFromHexWKB(text) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(intset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(bigintset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(floatset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(textset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(dateset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tstzset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(intset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(bigintset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(floatset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(textset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(dateset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tstzset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Set_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(intset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(bigintset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(floatset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(textset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(dateset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(tstzset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Set_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor functions + ******************************************************************************/ + +CREATE FUNCTION set(integer[]) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(bigint[]) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(float[]) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(text[]) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(date[]) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(timestamptz[]) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION set(integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(date) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set(timestamptz) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Value_to_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (integer AS intset) WITH FUNCTION set(integer); +CREATE CAST (bigint AS bigintset) WITH FUNCTION set(bigint); +CREATE CAST (float AS floatset) WITH FUNCTION set(float); +CREATE CAST (text AS textset) WITH FUNCTION set(text); +CREATE CAST (date AS dateset) WITH FUNCTION set(date); +CREATE CAST (timestamptz AS tstzset) WITH FUNCTION set(timestamptz); + +CREATE FUNCTION floatset(intset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Intset_to_floatset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intset(floatset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Floatset_to_intset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intset AS floatset) WITH FUNCTION floatset(intset); +CREATE CAST (floatset AS intset) WITH FUNCTION intset(floatset); + +CREATE FUNCTION tstzset(dateset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Dateset_to_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dateset(tstzset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Tstzset_to_dateset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (dateset AS tstzset) WITH FUNCTION tstzset(dateset); +CREATE CAST (tstzset AS dateset) WITH FUNCTION dateset(tstzset); + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION memSize(intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(bigintset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(floatset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(textset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tstzset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numValues(intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(bigintset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(floatset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(textset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numValues(tstzset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_num_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(bigintset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(floatset) + RETURNS float + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(textset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(dateset) + RETURNS date + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(tstzset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Set_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(bigintset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(floatset) + RETURNS float + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(textset) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(dateset) + RETURNS date + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(tstzset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Set_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(intset, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(bigintset, integer) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(floatset, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(textset, integer) + RETURNS text + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(dateset, integer) + RETURNS date + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(tstzset, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Set_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/* Values is a reserved word in SQL */ +CREATE FUNCTION getValues(intset) + RETURNS integer[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(bigintset) + RETURNS bigint[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(floatset) + RETURNS float[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(textset) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(dateset) + RETURNS date[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(tstzset) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Set_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION shift(intset, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Numset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(bigintset, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Numset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(floatset, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Numset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(dateset, integer) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Numset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(tstzset, interval) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Tstzset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scale(intset, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Numset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(bigintset, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Numset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(floatset, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Numset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(dateset, integer) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Numset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(tstzset, interval) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Tstzset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScale(intset, integer, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Numset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(bigintset, bigint, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Numset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(floatset, float, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Numset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(dateset, integer, integer) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Numset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(tstzset, interval, interval) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Tstzset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floor(floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Floatset_floor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ceil(floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Floatset_ceil' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(floatset, integer DEFAULT 0) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION degrees(floatset, bool DEFAULT FALSE) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Floatset_degrees' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION radians(floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Floatset_radians' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lower(textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Textset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Textset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION initcap(textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Textset_initcap' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transform a set to a set of values + ******************************************************************************/ + +CREATE FUNCTION unnest(intset) + RETURNS SETOF integer + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(bigintset) + RETURNS SETOF bigint + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(floatset) + RETURNS SETOF float + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(textset) + RETURNS SETOF text + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(dateset) + RETURNS SETOF date + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(tstzset) + RETURNS SETOF timestamptz + AS 'MODULE_PATHNAME', 'Set_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Temporal text concatenation + *****************************************************************************/ + +CREATE FUNCTION textset_cat(text, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Textcat_text_textset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION textset_cat(textset, text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Textcat_textset_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR || ( + PROCEDURE = textset_cat, + LEFTARG = text, RIGHTARG = textset +); +CREATE OPERATOR || ( + PROCEDURE = textset_cat, + LEFTARG = textset, RIGHTARG = text +); + +/****************************************************************************** + * Aggregate functions + ******************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, integer) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, bigint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, float) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, text) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, date) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, timestamptz) + RETURNS internal + AS 'MODULE_PATHNAME', 'Value_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not STRICT +CREATE FUNCTION set_union_transfn(internal, intset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, bigintset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, floatset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, textset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, dateset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_union_transfn(internal, tstzset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION intset_union_finalfn(internal) + RETURNS intset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION bigintset_union_finalfn(internal) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION floatset_union_finalfn(internal) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION dateset_union_finalfn(internal) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tstzset_union_finalfn(internal) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION textset_union_finalfn(internal) + RETURNS textset + AS 'MODULE_PATHNAME', 'Set_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE setUnion(integer) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = intset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(bigint) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = bigintset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(float) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = floatset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(text) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = textset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(date) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = dateset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(timestamptz) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = tstzset_union_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE setUnion(intset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = intset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(bigintset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = bigintset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(floatset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = floatset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(textset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = textset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(dateset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = dateset_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE setUnion(tstzset) ( + SFUNC = set_union_transfn, + STYPE = internal, + FINALFUNC = tstzset_union_finalfn, + PARALLEL = safe +); + +/***************************************************************************** + * Selectivity functions + *****************************************************************************/ + +CREATE FUNCTION span_sel(internal, oid, internal, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'Span_sel' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_joinsel(internal, oid, internal, smallint, internal) + RETURNS float + AS 'MODULE_PATHNAME', 'Span_joinsel' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Comparison functions for defining B-tree indexes + ******************************************************************************/ + +CREATE FUNCTION set_eq(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_eq(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_ne(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ne(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_lt(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_lt(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_le(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_le(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_ge(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_ge(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gt(intset, intset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(bigintset, bigintset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(floatset, floatset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(textset, textset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(dateset, dateset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gt(tstzset, tstzset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Set_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_cmp(intset, intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(bigintset, bigintset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(floatset, floatset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(textset, textset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(dateset, dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_cmp(tstzset, tstzset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR <= ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR >= ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR > ( + LEFTARG = intset, RIGHTARG = intset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = bigintset, RIGHTARG = bigintset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = floatset, RIGHTARG = floatset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = textset, RIGHTARG = textset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = dateset, RIGHTARG = dateset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tstzset, RIGHTARG = tstzset, + PROCEDURE = set_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS intset_btree_ops + DEFAULT FOR TYPE intset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(intset, intset); +CREATE OPERATOR CLASS bigintset_btree_ops + DEFAULT FOR TYPE bigintset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(bigintset, bigintset); +CREATE OPERATOR CLASS floatset_btree_ops + DEFAULT FOR TYPE floatset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(floatset, floatset); +CREATE OPERATOR CLASS textset_btree_ops + DEFAULT FOR TYPE textset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(textset, textset); +CREATE OPERATOR CLASS dateset_btree_ops + DEFAULT FOR TYPE dateset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(dateset, dateset); +CREATE OPERATOR CLASS tstzset_btree_ops + DEFAULT FOR TYPE tstzset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 set_cmp(tstzset, tstzset); + +/****************************************************************************** + * Hash functions for defining hash indexes + ******************************************************************************/ + +CREATE FUNCTION set_hash(intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(bigintset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(floatset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(textset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash(tstzset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Set_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_hash_extended(intset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(bigintset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(floatset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(textset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(dateset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_hash_extended(tstzset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Set_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS intset_hash_ops + DEFAULT FOR TYPE intset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(intset), + FUNCTION 2 set_hash_extended(intset, bigint); +CREATE OPERATOR CLASS bigintset_hash_ops + DEFAULT FOR TYPE bigintset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(bigintset), + FUNCTION 2 set_hash_extended(bigintset, bigint); +CREATE OPERATOR CLASS floatset_hash_ops + DEFAULT FOR TYPE floatset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(floatset), + FUNCTION 2 set_hash_extended(floatset, bigint); +CREATE OPERATOR CLASS textset_hash_ops + DEFAULT FOR TYPE textset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(textset), + FUNCTION 2 set_hash_extended(textset, bigint); +CREATE OPERATOR CLASS dateset_hash_ops + DEFAULT FOR TYPE dateset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(dateset), + FUNCTION 2 set_hash_extended(dateset, bigint); +CREATE OPERATOR CLASS tstzset_hash_ops + DEFAULT FOR TYPE tstzset USING hash AS + OPERATOR 1 = , + FUNCTION 1 set_hash(tstzset), + FUNCTION 2 set_hash_extended(tstzset, bigint); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/002_set_ops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/002_set_ops.in.sql new file mode 100644 index 0000000..b449b0c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/002_set_ops.in.sql @@ -0,0 +1,1720 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Operators for set types + */ + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION set_contains(intset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(bigintset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(floatset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(textset, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(dateset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(tstzset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contains(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = textset, RIGHTARG = text, + COMMUTATOR = <@ +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = <@ +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = <@ +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = <@ +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = set_contains, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_contained(integer, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(bigint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(float, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(text, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(date, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(timestamptz, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_contained(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = text, RIGHTARG = textset, + COMMUTATOR = @> +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = @> +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = @> +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = @> +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = set_contained, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overlaps(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overlaps(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = && +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = && +); +CREATE OPERATOR && ( + PROCEDURE = set_overlaps, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_left(integer, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(intset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(bigint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(bigintset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(float, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(floatset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(text, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(textset, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(date, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(dateset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(timestamptz, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(tstzset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_left(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = text, RIGHTARG = textset, + COMMUTATOR = >> +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = textset, RIGHTARG = text, + COMMUTATOR = >> +); +CREATE OPERATOR << ( + PROCEDURE = set_left, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = >> +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = #>> +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = #>> +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = #>> +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = set_left, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_right(integer, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(intset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(bigint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(bigintset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(float, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(floatset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(text, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(textset, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(date, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(dateset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(timestamptz, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(tstzset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_right(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = text, RIGHTARG = textset, + COMMUTATOR = << +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = textset, RIGHTARG = text, + COMMUTATOR = << +); +CREATE OPERATOR >> ( + PROCEDURE = set_right, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = << +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = <<# +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = <<# +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = <<# +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = set_right, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overleft(integer, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(intset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(bigint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(bigintset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(float, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(floatset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(text, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(textset, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(date, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(dateset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(timestamptz, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(tstzset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overleft(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = integer, RIGHTARG = intset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = intset, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = intset, RIGHTARG = intset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = bigint, RIGHTARG = bigintset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = bigintset, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = bigintset, RIGHTARG = bigintset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = float, RIGHTARG = floatset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = floatset, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = floatset, RIGHTARG = floatset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = text, RIGHTARG = textset +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = textset, RIGHTARG = text +); +CREATE OPERATOR &< ( + PROCEDURE = set_overleft, + LEFTARG = textset, RIGHTARG = textset +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = date, RIGHTARG = dateset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = dateset, RIGHTARG = date, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = dateset, RIGHTARG = dateset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = timestamptz, RIGHTARG = tstzset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = tstzset, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = set_overleft, + LEFTARG = tstzset, RIGHTARG = tstzset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION set_overright(integer, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(intset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(intset, intset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(bigint, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(bigintset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(bigintset, bigintset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(float, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(floatset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(floatset, floatset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(text, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(textset, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(textset, textset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(date, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(dateset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(dateset, dateset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(timestamptz, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(tstzset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_overright(tstzset, tstzset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = integer, RIGHTARG = intset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = intset, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = intset, RIGHTARG = intset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = bigint, RIGHTARG = bigintset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = bigintset, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = bigintset, RIGHTARG = bigintset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = float, RIGHTARG = floatset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = floatset, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = floatset, RIGHTARG = floatset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = text, RIGHTARG = textset +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = textset, RIGHTARG = text +); +CREATE OPERATOR &> ( + PROCEDURE = set_overright, + LEFTARG = textset, RIGHTARG = textset +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = date, RIGHTARG = dateset +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = dateset, RIGHTARG = date +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = dateset, RIGHTARG = dateset +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = timestamptz, RIGHTARG = tstzset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = tstzset, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = set_overright, + LEFTARG = tstzset, RIGHTARG = tstzset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION set_union(integer, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(intset, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(intset, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(bigint, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(bigintset, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(bigintset, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(float, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(floatset, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(floatset, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(text, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(textset, text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(textset, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(date, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(dateset, date) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(dateset, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_union(timestamptz, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Union_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(tstzset, timestamptz) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Union_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_union(tstzset, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Union_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = text, RIGHTARG = textset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = textset, RIGHTARG = text, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = + +); + +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = set_union, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION set_minus(integer, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(intset, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(intset, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(bigint, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(bigintset, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(bigintset, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(float, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(floatset, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(floatset, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(text, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(textset, text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(textset, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(date, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(dateset, date) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(dateset, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_minus(timestamptz, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Minus_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(tstzset, timestamptz) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Minus_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_minus(tstzset, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Minus_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = integer, RIGHTARG = intset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = intset, RIGHTARG = integer +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = intset, RIGHTARG = intset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = bigint, RIGHTARG = bigintset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = bigintset, RIGHTARG = bigint +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = bigintset, RIGHTARG = bigintset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = float, RIGHTARG = floatset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = floatset, RIGHTARG = float +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = floatset, RIGHTARG = floatset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = text, RIGHTARG = textset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = textset, RIGHTARG = text +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = textset, RIGHTARG = textset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = date, RIGHTARG = dateset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = dateset, RIGHTARG = date +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = dateset, RIGHTARG = dateset +); + +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = timestamptz, RIGHTARG = tstzset +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = tstzset, RIGHTARG = timestamptz +); +CREATE OPERATOR - ( + PROCEDURE = set_minus, + LEFTARG = tstzset, RIGHTARG = tstzset +); + +/*****************************************************************************/ + +CREATE FUNCTION set_intersection(integer, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(intset, integer) + RETURNS intset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(intset, intset) + RETURNS intset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(bigint, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(bigintset, bigint) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(bigintset, bigintset) + RETURNS bigintset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(float, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(floatset, float) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(floatset, floatset) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(text, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(textset, text) + RETURNS textset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(textset, textset) + RETURNS textset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(date, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(dateset, date) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(dateset, dateset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_intersection(timestamptz, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Intersection_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(tstzset, timestamptz) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Intersection_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_intersection(tstzset, tstzset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Intersection_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = text, RIGHTARG = textset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = textset, RIGHTARG = text, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = textset, RIGHTARG = textset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = * +); + +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = set_intersection, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = * +); + +/*****************************************************************************/ + +CREATE FUNCTION set_distance(integer, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(integer, intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(intset, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(intset, intset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_distance(bigint, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_value_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(bigint, bigintset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(bigintset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(bigintset, bigintset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_distance(float, float) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(float, floatset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(floatset, float) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(floatset, floatset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_distance(date, date) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(date, dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(dateset, date) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(dateset, dateset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_distance(timestamptz, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(timestamptz, tstzset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(tstzset, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_distance(tstzset, tstzset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_set_set' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = integer, RIGHTARG = integer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = integer, RIGHTARG = intset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = intset, RIGHTARG = integer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = intset, RIGHTARG = intset, + COMMUTATOR = <-> +); + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = bigint, RIGHTARG = bigint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = bigint, RIGHTARG = bigintset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = bigintset, RIGHTARG = bigint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = bigintset, RIGHTARG = bigintset, + COMMUTATOR = <-> +); + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = float, RIGHTARG = float, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = float, RIGHTARG = floatset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = floatset, RIGHTARG = float, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = floatset, RIGHTARG = floatset, + COMMUTATOR = <-> +); + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = date, RIGHTARG = date, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = date, RIGHTARG = dateset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = dateset, RIGHTARG = date, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = dateset, RIGHTARG = dateset, + COMMUTATOR = <-> +); + +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = timestamptz, RIGHTARG = timestamptz, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = timestamptz, RIGHTARG = tstzset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = tstzset, RIGHTARG = timestamptz, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = set_distance, + LEFTARG = tstzset, RIGHTARG = tstzset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/003_span.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/003_span.in.sql new file mode 100644 index 0000000..9338883 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/003_span.in.sql @@ -0,0 +1,1233 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief SQL definitions for spans of values, which are fixed-size version of + * PostgreSQL ranges + */ + +CREATE TYPE intspan; +CREATE TYPE bigintspan; +CREATE TYPE floatspan; +CREATE TYPE datespan; +CREATE TYPE tstzspan; + +/* Forward reference of the types needed for the result of set operations */ +CREATE TYPE intspanset; +CREATE TYPE bigintspanset; +CREATE TYPE floatspanset; +CREATE TYPE datespanset; +CREATE TYPE tstzspanset; + +CREATE FUNCTION intspan_in(cstring) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intspan_out(intspan) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Span_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intspan_recv(internal) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION intspan_send(intspan) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION bigintspan_in(cstring) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspan_out(bigintspan) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Span_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspan_recv(internal) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspan_send(bigintspan) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floatspan_in(cstring) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan_out(floatspan) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Span_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan_recv(internal) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan_send(floatspan) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION datespan_in(cstring) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespan_out(datespan) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Span_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespan_recv(internal) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespan_send(datespan) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tstzspan_in(cstring) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspan_out(tstzspan) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Span_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspan_recv(internal) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspan_send(tstzspan) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/* The span_analyze function is defined in file 001_set.in.sql */ + +CREATE TYPE intspan ( + internallength = 24, + input = intspan_in, + output = intspan_out, + receive = intspan_recv, + send = intspan_send, + alignment = double, + analyze = span_analyze +); + +CREATE TYPE bigintspan ( + internallength = 24, + input = bigintspan_in, + output = bigintspan_out, + receive = bigintspan_recv, + send = bigintspan_send, + alignment = double, + analyze = span_analyze +); + +CREATE TYPE floatspan ( + internallength = 24, + input = floatspan_in, + output = floatspan_out, + receive = floatspan_recv, + send = floatspan_send, + alignment = double, + analyze = span_analyze +); + +CREATE TYPE datespan ( + internallength = 24, + input = datespan_in, + output = datespan_out, + receive = datespan_recv, + send = datespan_send, + alignment = double, + analyze = span_analyze +); + +CREATE TYPE tstzspan ( + internallength = 24, + input = tstzspan_in, + output = tstzspan_out, + receive = tstzspan_recv, + send = tstzspan_send, + alignment = double, + analyze = span_analyze +); + +/******************************************************************************/ + +-- Input/output in WKT, WKB and HexWKB representation + +CREATE FUNCTION intspanFromBinary(bytea) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanFromBinary(bytea) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanFromBinary(bytea) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanFromBinary(bytea) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanFromBinary(bytea) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspanFromHexWKB(text) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanFromHexWKB(text) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanFromHexWKB(text) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanFromHexWKB(text) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanFromHexWKB(text) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(intspan) + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(bigintspan) + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(floatspan, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(datespan) + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tstzspan) + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(intspan, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(bigintspan, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(floatspan, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(datespan, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tstzspan, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Span_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(intspan, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(bigintspan, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(floatspan, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(datespan, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(tstzspan, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Span_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor functions + ******************************************************************************/ + +CREATE FUNCTION span(integer, integer, boolean DEFAULT true, boolean DEFAULT false) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(bigint, bigint, boolean DEFAULT true, boolean DEFAULT false) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(float, float, boolean DEFAULT true, boolean DEFAULT false) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(date, date, boolean DEFAULT true, boolean DEFAULT false) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(timestamptz, timestamptz, boolean DEFAULT true, boolean DEFAULT false) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION span(integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Value_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Value_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Value_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(date) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Value_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(timestamptz) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Value_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (integer AS intspan) WITH FUNCTION span(integer); +CREATE CAST (bigint AS bigintspan) WITH FUNCTION span(bigint); +CREATE CAST (float AS floatspan) WITH FUNCTION span(float); +CREATE CAST (date AS datespan) WITH FUNCTION span(date); +CREATE CAST (timestamptz AS tstzspan) WITH FUNCTION span(timestamptz); + +CREATE FUNCTION span(intset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Set_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(bigintset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Set_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(floatset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Set_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(dateset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Set_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(tstzset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Set_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intset AS intspan) WITH FUNCTION span(intset); +CREATE CAST (bigintset AS bigintspan) WITH FUNCTION span(bigintset); +CREATE CAST (floatset AS floatspan) WITH FUNCTION span(floatset); +CREATE CAST (dateset AS datespan) WITH FUNCTION span(dateset); +CREATE CAST (tstzset AS tstzspan) WITH FUNCTION span(tstzset); + +CREATE FUNCTION spans(intset) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Set_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(bigintset) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Set_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(floatset) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Set_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(dateset) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Set_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tstzset) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Set_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNSpans(intset, integer) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Set_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(bigintset, integer) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Set_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(floatset, integer) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Set_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(dateset, integer) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Set_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tstzset, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Set_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNSpans(intset, integer) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Set_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(bigintset, integer) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Set_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(floatset, integer) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Set_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(dateset, integer) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Set_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tstzset, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Set_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspan(floatspan) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Floatspan_to_intspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan(intspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Intspan_to_floatspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intspan AS floatspan) WITH FUNCTION floatspan(intspan); +CREATE CAST (floatspan AS intspan) WITH FUNCTION intspan(floatspan); + +CREATE FUNCTION datespan(tstzspan) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Tstzspan_to_datespan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspan(datespan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Datespan_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (datespan AS tstzspan) WITH FUNCTION tstzspan(datespan); +CREATE CAST (tstzspan AS datespan) WITH FUNCTION datespan(tstzspan); + +CREATE FUNCTION span(int4range) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Range_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(int8range) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Range_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(daterange) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Range_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(tstzrange) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Range_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION range(intspan) + RETURNS int4range + AS 'MODULE_PATHNAME', 'Span_to_range' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION range(bigintspan) + RETURNS int8range + AS 'MODULE_PATHNAME', 'Span_to_range' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION range(datespan) + RETURNS daterange + AS 'MODULE_PATHNAME', 'Span_to_range' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION range(tstzspan) + RETURNS tstzrange + AS 'MODULE_PATHNAME', 'Span_to_range' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (int4range AS intspan) WITH FUNCTION span(int4range); +CREATE CAST (int8range AS bigintspan) WITH FUNCTION span(int8range); +CREATE CAST (daterange AS datespan) WITH FUNCTION span(daterange); +CREATE CAST (tstzrange AS tstzspan) WITH FUNCTION span(tstzrange); +CREATE CAST (intspan AS int4range) WITH FUNCTION range(intspan); +CREATE CAST (bigintspan AS int8range) WITH FUNCTION range(bigintspan); +CREATE CAST (datespan AS daterange) WITH FUNCTION range(datespan); +CREATE CAST (tstzspan AS tstzrange) WITH FUNCTION range(tstzspan); + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION lower(intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Span_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(datespan) + RETURNS date + AS 'MODULE_PATHNAME', 'Span_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(tstzspan) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Span_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upper(intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Span_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(datespan) + RETURNS date + AS 'MODULE_PATHNAME', 'Span_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(tstzspan) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Span_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION width(intspan) + RETURNS int + AS 'MODULE_PATHNAME', 'Numspan_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION width(bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Numspan_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION width(floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Numspan_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(datespan) + RETURNS interval + AS 'MODULE_PATHNAME', 'Datespan_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tstzspan) + RETURNS interval + AS 'MODULE_PATHNAME', 'Tstzspan_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION expand(intspan, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Numspan_expand' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expand(bigintspan, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Numspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expand(floatspan, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Numspan_expand' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expand(datespan, integer) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Numspan_expand' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expand(tstzspan, interval) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tstzspan_expand' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shift(timestamptz, interval) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Timestamptz_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shift(intspan, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Numspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(bigintspan, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Numspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(floatspan, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Numspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(datespan, integer) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Numspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(tstzspan, interval) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tstzspan_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scale(intspan, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Numspan_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(bigintspan, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Numspan_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(floatspan, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Numspan_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(datespan, integer) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Numspan_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(tstzspan, interval) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tstzspan_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScale(intspan, integer, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Numspan_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(bigintspan, bigint, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Numspan_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(floatspan, float, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Numspan_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(datespan, integer, integer) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Numspan_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(tstzspan, interval, interval) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tstzspan_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floor(floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Floatspan_floor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ceil(floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Floatspan_ceil' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(float, integer DEFAULT 0) + RETURNS float + AS 'MODULE_PATHNAME', 'Float_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(floatspan, integer DEFAULT 0) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Floatspan_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION degrees(floatspan, bool DEFAULT FALSE) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Floatspan_degrees' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION radians(floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Floatspan_radians' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Selectivity functions + *****************************************************************************/ + +-- Functions span_sel and span_joinsel are defined in the file defining the +-- set type + +-- Functions for debugging the selectivity code + +-- Given a table, column, and span returns the estimate of what proportion +-- of the table would be returned by a query using the given operator. +CREATE FUNCTION _mobdb_span_sel(tbl regclass, col text, oper regoper, + i intspan) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION _mobdb_span_sel(tbl regclass, col text, oper regoper, + b bigintspan) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION _mobdb_span_sel(tbl regclass, col text, oper regoper, + f floatspan) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION _mobdb_span_sel(tbl regclass, col text, oper regoper, + p datespan) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION _mobdb_span_sel(tbl regclass, col text, oper regoper, + p tstzspan) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- Given two tables and columns, returns estimate of the proportion of rows a +-- given join operator will return relative to the number of rows an +-- unconstrained table join would return +CREATE OR REPLACE FUNCTION _mobdb_span_joinsel(tbl1 regclass, col1 text, + tbl2 regclass, col2 text, oper regoper) + RETURNS float + AS 'MODULE_PATHNAME' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Comparison operators + ******************************************************************************/ + +CREATE FUNCTION span_eq(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_eq(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_eq(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_eq(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_eq(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_ne(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ne(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ne(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ne(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ne(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_lt(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_lt(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_lt(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_lt(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_lt(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_le(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_le(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_le(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_le(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_le(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_ge(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ge(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ge(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ge(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_ge(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_gt(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gt(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gt(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gt(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gt(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Span_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_cmp(intspan, intspan) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Span_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_cmp(bigintspan, bigintspan) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Span_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_cmp(floatspan, floatspan) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Span_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_cmp(datespan, datespan) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Span_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_cmp(tstzspan, tstzspan) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Span_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + PROCEDURE = span_eq, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + PROCEDURE = span_eq, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + PROCEDURE = span_eq, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + PROCEDURE = span_eq, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + PROCEDURE = span_eq, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + PROCEDURE = span_ne, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = span_ne, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = span_ne, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = span_ne, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + PROCEDURE = span_ne, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + PROCEDURE = span_lt, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + PROCEDURE = span_lt, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + PROCEDURE = span_lt, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + PROCEDURE = span_lt, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + PROCEDURE = span_lt, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR <= ( + PROCEDURE = span_le, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + PROCEDURE = span_le, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + PROCEDURE = span_le, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + PROCEDURE = span_le, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + PROCEDURE = span_le, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR >= ( + PROCEDURE = span_ge, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + PROCEDURE = span_ge, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + PROCEDURE = span_ge, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + PROCEDURE = span_ge, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + PROCEDURE = span_ge, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR > ( + PROCEDURE = span_gt, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + PROCEDURE = span_gt, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + PROCEDURE = span_gt, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + PROCEDURE = span_gt, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + PROCEDURE = span_gt, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS intspan_btree_ops + DEFAULT FOR TYPE intspan USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 span_cmp(intspan, intspan); +CREATE OPERATOR CLASS bigintspan_btree_ops + DEFAULT FOR TYPE bigintspan USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 span_cmp(bigintspan, bigintspan); +CREATE OPERATOR CLASS floatspan_btree_ops + DEFAULT FOR TYPE floatspan USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 span_cmp(floatspan, floatspan); +CREATE OPERATOR CLASS datespan_btree_ops + DEFAULT FOR TYPE datespan USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 span_cmp(datespan, datespan); +CREATE OPERATOR CLASS tstzspan_btree_ops + DEFAULT FOR TYPE tstzspan USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 span_cmp(tstzspan, tstzspan); + +/******************************************************************************/ + +CREATE FUNCTION span_hash(intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash(bigintspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash(floatspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash(datespan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash(tstzspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Span_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_hash_extended(intspan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash_extended(bigintspan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash_extended(floatspan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash_extended(datespan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_hash_extended(tstzspan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Span_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS intspan_hash_ops + DEFAULT FOR TYPE intspan USING hash AS + OPERATOR 1 = , + FUNCTION 1 span_hash(intspan), + FUNCTION 2 span_hash_extended(intspan, bigint); +CREATE OPERATOR CLASS bigintspan_hash_ops + DEFAULT FOR TYPE bigintspan USING hash AS + OPERATOR 1 = , + FUNCTION 1 span_hash(bigintspan), + FUNCTION 2 span_hash_extended(bigintspan, bigint); +CREATE OPERATOR CLASS floatspan_hash_ops + DEFAULT FOR TYPE floatspan USING hash AS + OPERATOR 1 = , + FUNCTION 1 span_hash(floatspan), + FUNCTION 2 span_hash_extended(floatspan, bigint); +CREATE OPERATOR CLASS datespan_hash_ops + DEFAULT FOR TYPE datespan USING hash AS + OPERATOR 1 = , + FUNCTION 1 span_hash(datespan), + FUNCTION 2 span_hash_extended(datespan, bigint); +CREATE OPERATOR CLASS tstzspan_hash_ops + DEFAULT FOR TYPE tstzspan USING hash AS + OPERATOR 1 = , + FUNCTION 1 span_hash(tstzspan), + FUNCTION 2 span_hash_extended(tstzspan, bigint); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/005_span_ops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/005_span_ops.in.sql new file mode 100644 index 0000000..8305567 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/005_span_ops.in.sql @@ -0,0 +1,1694 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Operators for span types + */ + +/****************************************************************************** + * Topological operators + ******************************************************************************/ + +CREATE FUNCTION span_contains(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_contained(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_overlaps(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_adjacent(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/****************************************************************************** + * Position operators + ******************************************************************************/ + +CREATE FUNCTION span_left(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_right(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_overleft(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = integer, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspan, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspan, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigint, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspan, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = float, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspan, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspan, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = date, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespan, RIGHTARG = date, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespan, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/******************************************************************************/ + +CREATE FUNCTION span_overright(integer, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspan, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspan, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = integer, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspan, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspan, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(bigint, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspan, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspan, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigint, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspan, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(float, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspan, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspan, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = float, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspan, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspan, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(date, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespan, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespan, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = date, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespan, RIGHTARG = date, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespan, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(timestamptz, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspan, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspan, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/***************************************************************************** + * Set operators + *****************************************************************************/ + +CREATE FUNCTION span_union(integer, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspan, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspan, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(bigint, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspan, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspan, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(float, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspan, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspan, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(date, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespan, date) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespan, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(timestamptz, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspan, timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspan, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = + +); + +/******************************************************************************/ + +CREATE FUNCTION span_intersection(integer, intspan) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Intersection_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspan, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Intersection_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspan, intspan) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Intersection_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(bigint, bigintspan) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Intersection_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspan, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Intersection_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspan, bigintspan) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Intersection_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(float, floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Intersection_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspan, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Intersection_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspan, floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Intersection_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(date, datespan) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Intersection_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespan, date) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Intersection_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespan, datespan) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Intersection_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(timestamptz, tstzspan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Intersection_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspan, timestamptz) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Intersection_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspan, tstzspan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Intersection_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = * +); + +/******************************************************************************/ + +CREATE FUNCTION span_minus(integer, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspan, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspan, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = - +); + +CREATE FUNCTION span_minus(bigint, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspan, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspan, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = - +); + +CREATE FUNCTION span_minus(float, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspan, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspan, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = - +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = - +); + +CREATE FUNCTION span_minus(date, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespan, date) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespan, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = date, RIGHTARG = datespan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespan, RIGHTARG = date +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespan, RIGHTARG = datespan +); + +CREATE FUNCTION span_minus(timestamptz, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspan, timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspan, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = timestamptz, RIGHTARG = tstzspan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspan, RIGHTARG = timestamptz +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspan, RIGHTARG = tstzspan +); + +/***************************************************************************** + * Distance operators + *****************************************************************************/ + +CREATE FUNCTION span_distance(integer, intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspan, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspan, intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = integer, RIGHTARG = intspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspan, RIGHTARG = integer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspan, RIGHTARG = intspan, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(bigint, bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspan, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspan, bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigint, RIGHTARG = bigintspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspan, RIGHTARG = bigint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspan, RIGHTARG = bigintspan, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(float, floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspan, float) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspan, floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = float, RIGHTARG = floatspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspan, RIGHTARG = float, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspan, RIGHTARG = floatspan, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(date, datespan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespan, date) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespan, datespan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = date, RIGHTARG = datespan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespan, RIGHTARG = date, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespan, RIGHTARG = datespan, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(timestamptz, tstzspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(tstzspan, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(tstzspan, tstzspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = timestamptz, RIGHTARG = tstzspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = tstzspan, RIGHTARG = timestamptz, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = tstzspan, RIGHTARG = tstzspan, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/007_spanset.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/007_spanset.in.sql new file mode 100644 index 0000000..6d472ce --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/007_spanset.in.sql @@ -0,0 +1,1364 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for set of spans of values, which are fixed-size versions + * of PostgreSQL multiranges + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION intspanset_in(cstring) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Spanset_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanset_in(cstring) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Spanset_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanset_in(cstring) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Spanset_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanset_in(cstring) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Spanset_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanset_in(cstring) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Spanset_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspanset_out(intspanset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Spanset_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanset_out(bigintspanset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Spanset_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanset_out(floatspanset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Spanset_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanset_out(datespanset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Spanset_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanset_out(tstzspanset) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Spanset_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspanset_recv(internal) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Spanset_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanset_recv(internal) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Spanset_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanset_recv(internal) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Spanset_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanset_recv(internal) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Spanset_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanset_recv(internal) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Spanset_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspanset_send(intspanset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspanset_send(bigintspanset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanset_send(floatspanset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespanset_send(datespanset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanset_send(tstzspanset) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/* The span_analyze function is defined in file 001_set.in.sql */ + +CREATE TYPE intspanset ( + internallength = variable, + input = intspanset_in, + output = intspanset_out, + receive = intspanset_recv, + send = intspanset_send, + alignment = double, +-- The following line makes NULL if size < 128 + storage = extended, + analyze = span_analyze +); +CREATE TYPE bigintspanset ( + internallength = variable, + input = bigintspanset_in, + output = bigintspanset_out, + receive = bigintspanset_recv, + send = bigintspanset_send, + alignment = double, +-- The following line makes NULL if size < 128 + storage = extended, + analyze = span_analyze +); +CREATE TYPE floatspanset ( + internallength = variable, + input = floatspanset_in, + output = floatspanset_out, + receive = floatspanset_recv, + send = floatspanset_send, + alignment = double, +-- The following line makes NULL if size < 128 + storage = extended, + analyze = span_analyze +); +CREATE TYPE datespanset ( + internallength = variable, + input = datespanset_in, + output = datespanset_out, + receive = datespanset_recv, + send = datespanset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); +CREATE TYPE tstzspanset ( + internallength = variable, + input = tstzspanset_in, + output = tstzspanset_out, + receive = tstzspanset_recv, + send = tstzspanset_send, + alignment = double, + storage = extended, + analyze = span_analyze +); + +/******************************************************************************/ + +-- Input/output in WKB and HexWKB representation + +CREATE FUNCTION intspansetFromBinary(bytea) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Spanset_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspansetFromBinary(bytea) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Spanset_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspansetFromBinary(bytea) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Spanset_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespansetFromBinary(bytea) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Spanset_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspansetFromBinary(bytea) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Spanset_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION intspansetFromHexWKB(text) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Spanset_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspansetFromHexWKB(text) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Spanset_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspansetFromHexWKB(text) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Spanset_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespansetFromHexWKB(text) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Spanset_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspansetFromHexWKB(text) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Spanset_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(intspanset) + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(bigintspanset) + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(floatspanset, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(datespanset) + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tstzspanset) + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(intspanset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(bigintspanset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(floatspanset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(datespanset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tstzspanset, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Spanset_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(intspanset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(bigintspanset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(floatspanset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(datespanset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(tstzspanset, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Spanset_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor functions + ******************************************************************************/ + +CREATE FUNCTION spanset(intspan[]) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Spanset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(bigintspan[]) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Spanset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(floatspan[]) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Spanset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(datespan[]) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Spanset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(tstzspan[]) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Spanset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION spanset(integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Value_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Value_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Value_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(date) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Value_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Value_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (integer AS intspanset) WITH FUNCTION spanset(integer); +CREATE CAST (bigint AS bigintspanset) WITH FUNCTION spanset(bigint); +CREATE CAST (float AS floatspanset) WITH FUNCTION spanset(float); +CREATE CAST (date AS datespanset) WITH FUNCTION spanset(date); +CREATE CAST (timestamptz AS tstzspanset) WITH FUNCTION spanset(timestamptz); + +CREATE FUNCTION spanset(intset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Set_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(bigintset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Set_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(floatset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Set_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(dateset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Set_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(tstzset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Set_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intset AS intspanset) WITH FUNCTION spanset(intset); +CREATE CAST (bigintset AS bigintspanset) WITH FUNCTION spanset(bigintset); +CREATE CAST (floatset AS floatspanset) WITH FUNCTION spanset(floatset); +CREATE CAST (dateset AS datespanset) WITH FUNCTION spanset(dateset); +CREATE CAST (tstzset AS tstzspanset) WITH FUNCTION spanset(tstzset); + +CREATE FUNCTION spanset(intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Span_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Span_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Span_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Span_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Span_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intspan AS intspanset) WITH FUNCTION spanset(intspan); +CREATE CAST (bigintspan AS bigintspanset) WITH FUNCTION spanset(bigintspan); +CREATE CAST (floatspan AS floatspanset) WITH FUNCTION spanset(floatspan); +CREATE CAST (datespan AS datespanset) WITH FUNCTION spanset(datespan); +CREATE CAST (tstzspan AS tstzspanset) WITH FUNCTION spanset(tstzspan); + +CREATE FUNCTION span(intspanset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanset_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(bigintspanset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanset_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(floatspanset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanset_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(datespanset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanset_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span(tstzspanset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanset_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intspanset AS intspan) WITH FUNCTION span(intspanset); +CREATE CAST (bigintspanset AS bigintspan) WITH FUNCTION span(bigintspanset); +CREATE CAST (floatspanset AS floatspan) WITH FUNCTION span(floatspanset); +CREATE CAST (datespanset AS datespan) WITH FUNCTION span(datespanset); +CREATE CAST (tstzspanset AS tstzspan) WITH FUNCTION span(tstzspanset); + +CREATE FUNCTION intspanset(floatspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Floatspanset_to_intspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspanset(intspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intspanset_to_floatspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intspanset AS floatspanset) WITH FUNCTION floatspanset(intspanset); +CREATE CAST (floatspanset AS intspanset) WITH FUNCTION intspanset(floatspanset); + +CREATE FUNCTION datespanset(tstzspanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Tstzspanset_to_datespanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspanset(datespanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Datespanset_to_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (datespanset AS tstzspanset) WITH FUNCTION tstzspanset(datespanset); +CREATE CAST (tstzspanset AS datespanset) WITH FUNCTION datespanset(tstzspanset); + +#if POSTGRESQL_VERSION_NUMBER >= 140000 +CREATE FUNCTION multirange(intspanset) + RETURNS int4multirange + AS 'MODULE_PATHNAME', 'Spanset_to_multirange' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION multirange(bigintspanset) + RETURNS int8multirange + AS 'MODULE_PATHNAME', 'Spanset_to_multirange' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION multirange(datespanset) + RETURNS datemultirange + AS 'MODULE_PATHNAME', 'Spanset_to_multirange' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION multirange(tstzspanset) + RETURNS tstzmultirange + AS 'MODULE_PATHNAME', 'Spanset_to_multirange' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset(int4multirange) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Multirange_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(int8multirange) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Multirange_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(datemultirange) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Multirange_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset(tstzmultirange) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Multirange_to_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (intspanset AS int4multirange) WITH FUNCTION multirange(intspanset); +CREATE CAST (bigintspanset AS int8multirange) WITH FUNCTION multirange(bigintspanset); +CREATE CAST (datespanset AS datemultirange) WITH FUNCTION multirange(datespanset); +CREATE CAST (tstzspanset AS tstzmultirange) WITH FUNCTION multirange(tstzspanset); +CREATE CAST (int4multirange AS intspanset) WITH FUNCTION spanset(int4multirange); +CREATE CAST (int8multirange AS bigintspanset) WITH FUNCTION spanset(int8multirange); +CREATE CAST (datemultirange AS datespanset) WITH FUNCTION spanset(datemultirange); +CREATE CAST (tstzmultirange AS tstzspanset) WITH FUNCTION spanset(tstzmultirange); +#endif //POSTGRESQL_VERSION_NUMBER >= 140000 + +/****************************************************************************** + * Accessor Functions + ******************************************************************************/ + +CREATE FUNCTION memSize(intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(bigintspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(floatspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tstzspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lower(intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(bigintspanset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(floatspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Spanset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(datespanset) + RETURNS date + AS 'MODULE_PATHNAME', 'Spanset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lower(tstzspanset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Spanset_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upper(intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(bigintspanset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(floatspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Spanset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(datespanset) + RETURNS date + AS 'MODULE_PATHNAME', 'Spanset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upper(tstzspanset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Spanset_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Spanset_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION width(intspanset, boundspan boolean DEFAULT FALSE) + RETURNS int + AS 'MODULE_PATHNAME', 'Numspanset_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION width(bigintspanset, boundspan boolean DEFAULT FALSE) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Numspanset_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION width(floatspanset, boundspan boolean DEFAULT FALSE) + RETURNS float + AS 'MODULE_PATHNAME', 'Numspanset_width' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(datespanset, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Datespanset_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tstzspanset, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Tstzspanset_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSpans(intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_num_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSpans(bigintspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_num_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSpans(floatspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_num_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSpans(datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_num_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSpans(tstzspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_num_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSpan(intspanset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanset_start_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSpan(bigintspanset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanset_start_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSpan(floatspanset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanset_start_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSpan(datespanset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanset_start_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSpan(tstzspanset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanset_start_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSpan(intspanset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanset_end_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSpan(bigintspanset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanset_end_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSpan(floatspanset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanset_end_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSpan(datespanset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanset_end_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSpan(tstzspanset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanset_end_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanN(intspanset, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanset_span_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanN(bigintspanset, integer) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanset_span_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanN(floatspanset, integer) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanset_span_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanN(datespanset, integer) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanset_span_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanN(tstzspanset, integer) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanset_span_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numDates(datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Datespanset_num_dates' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startDate(datespanset) + RETURNS date + AS 'MODULE_PATHNAME', 'Datespanset_start_date' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endDate(datespanset) + RETURNS date + AS 'MODULE_PATHNAME', 'Datespanset_end_date' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dateN(datespanset, integer) + RETURNS date + AS 'MODULE_PATHNAME', 'Datespanset_date_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dates(datespanset) + RETURNS dateset + AS 'MODULE_PATHNAME', 'Datespanset_dates' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tstzspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tstzspanset_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tstzspanset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tstzspanset_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tstzspanset) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tstzspanset_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tstzspanset, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tstzspanset_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tstzspanset) + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Tstzspanset_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION shift(intspanset, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(bigintspanset, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(floatspanset, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(datespanset, integer) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Numspanset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shift(tstzspanset, interval) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Tstzspanset_shift' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scale(intspanset, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Numspanset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(bigintspanset, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Numspanset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(floatspanset, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Numspanset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(datespanset, integer) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Numspanset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scale(tstzspanset, interval) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Tstzspanset_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScale(intspanset, integer, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(bigintspanset, bigint, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(floatspanset, float, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Numspanset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(datespanset, integer, integer) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Numspanset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScale(tstzspanset, interval, interval) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Tstzspanset_shift_scale' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floor(floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Floatspanset_floor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ceil(floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Floatspanset_ceil' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(floatspanset, integer DEFAULT 0) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Floatspanset_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION degrees(floatspanset, bool DEFAULT FALSE) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Floatspanset_degrees' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION radians(floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Floatspanset_radians' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION spans(intspanset) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Spanset_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(bigintspanset) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Spanset_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(floatspanset) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Spanset_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(datespanset) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Spanset_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tstzspanset) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Spanset_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNSpans(intspanset, integer) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(bigintspanset, integer) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(floatspanset, integer) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(datespanset, integer) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Spanset_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tstzspanset, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNSpans(intspanset, integer) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(bigintspanset, integer) + RETURNS bigintspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(floatspanset, integer) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(datespanset, integer) + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Spanset_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tstzspanset, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Spanset_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Comparison operators + ******************************************************************************/ + +CREATE FUNCTION spanset_eq(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_eq(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_eq(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_eq(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_eq(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_ne(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ne(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ne(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ne(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ne(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_lt(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_lt(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_lt(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_lt(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_lt(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_le(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_le(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_le(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_le(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_le(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_ge(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ge(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ge(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ge(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_ge(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_gt(intspanset, intspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_gt(bigintspanset, bigintspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_gt(floatspanset, floatspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_gt(datespanset, datespanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_gt(tstzspanset, tstzspanset) + RETURNS bool + AS 'MODULE_PATHNAME', 'Spanset_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_cmp(intspanset, intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_cmp(bigintspanset, bigintspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_cmp(floatspanset, floatspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_cmp(datespanset, datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_cmp(tstzspanset, tstzspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); + +CREATE OPERATOR <> ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); + +CREATE OPERATOR < ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR < ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR <= ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR >= ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >= ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR > ( + LEFTARG = intspanset, RIGHTARG = intspanset, + PROCEDURE = spanset_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + PROCEDURE = spanset_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = floatspanset, RIGHTARG = floatspanset, + PROCEDURE = spanset_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = datespanset, RIGHTARG = datespanset, + PROCEDURE = spanset_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + PROCEDURE = spanset_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE OPERATOR CLASS intspanset_btree_ops + DEFAULT FOR TYPE intspanset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 spanset_cmp(intspanset, intspanset); +CREATE OPERATOR CLASS bigintspanset_btree_ops + DEFAULT FOR TYPE bigintspanset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 spanset_cmp(bigintspanset, bigintspanset); +CREATE OPERATOR CLASS floatspanset_btree_ops + DEFAULT FOR TYPE floatspanset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 spanset_cmp(floatspanset, floatspanset); +CREATE OPERATOR CLASS datespanset_btree_ops + DEFAULT FOR TYPE datespanset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 spanset_cmp(datespanset, datespanset); +CREATE OPERATOR CLASS tstzspanset_btree_ops + DEFAULT FOR TYPE tstzspanset USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 spanset_cmp(tstzspanset, tstzspanset); + +/******************************************************************************/ + +CREATE FUNCTION spanset_hash(intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash(bigintspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash(floatspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash(datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash(tstzspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Spanset_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION spanset_hash_extended(intspanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash_extended(bigintspanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash_extended(floatspanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash_extended(datespanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_hash_extended(tstzspanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Spanset_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS intspanset_hash_ops + DEFAULT FOR TYPE intspanset USING hash AS + OPERATOR 1 = , + FUNCTION 1 spanset_hash(intspanset), + FUNCTION 2 spanset_hash_extended(intspanset, bigint); +CREATE OPERATOR CLASS bigintspanset_hash_ops + DEFAULT FOR TYPE bigintspanset USING hash AS + OPERATOR 1 = , + FUNCTION 1 spanset_hash(bigintspanset), + FUNCTION 2 spanset_hash_extended(bigintspanset, bigint); +CREATE OPERATOR CLASS floatspanset_hash_ops + DEFAULT FOR TYPE floatspanset USING hash AS + OPERATOR 1 = , + FUNCTION 1 spanset_hash(floatspanset), + FUNCTION 2 spanset_hash_extended(floatspanset, bigint); +CREATE OPERATOR CLASS datespanset_hash_ops + DEFAULT FOR TYPE datespanset USING hash AS + OPERATOR 1 = , + FUNCTION 1 spanset_hash(datespanset), + FUNCTION 2 spanset_hash_extended(datespanset, bigint); +CREATE OPERATOR CLASS tstzspanset_hash_ops + DEFAULT FOR TYPE tstzspanset USING hash AS + OPERATOR 1 = , + FUNCTION 1 spanset_hash(tstzspanset), + FUNCTION 2 spanset_hash_extended(tstzspanset, bigint); + + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/009_spanset_ops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/009_spanset_ops.in.sql new file mode 100644 index 0000000..cfa8fc8 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/009_spanset_ops.in.sql @@ -0,0 +1,2829 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Operators for span set types + */ + +CREATE FUNCTION tprecision(timestamptz, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Timestamptz_tprecision' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION tprecision(tstzset, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tstzset + AS 'MODULE_PATHNAME', 'Tstzset_tprecision' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION tprecision(tstzspan, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tstzspan_tprecision' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION tprecision(tstzspanset, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Tstzspanset_tprecision' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/****************************************************************************** + * Operators + ******************************************************************************/ + +CREATE FUNCTION span_contains(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contains(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contains(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = span_contains, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = <@, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_contained(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_contained(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_contained(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = span_contained, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = @>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_overlaps(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overlaps(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overlaps(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = span_overlaps, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = &&, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_left(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR << ( + PROCEDURE = span_left, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = >>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_left(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_left(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = span_left, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = #>>, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_right(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR >> ( + PROCEDURE = span_right, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = <<, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_right(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_right(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = span_right, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = <<#, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_overleft(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = integer, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspan, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspanset, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspanset, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = intspanset, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigint, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspanset, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = float, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspan, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspanset, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspanset, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = span_overleft, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = date, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespan, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespanset, RIGHTARG = date, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespanset, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = datespanset, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overleft(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overleft(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = span_overleft, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_overright(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = integer, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspan, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspanset, RIGHTARG = integer, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspanset, RIGHTARG = intspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = intspanset, RIGHTARG = intspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigint, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspanset, RIGHTARG = bigint, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = float, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspan, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspanset, RIGHTARG = float, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspanset, RIGHTARG = floatspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = span_overright, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = date, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespan, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespanset, RIGHTARG = date, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespanset, RIGHTARG = datespan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = datespanset, RIGHTARG = datespanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_overright(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_overright(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = span_overright, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_adjacent(integer, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspan, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspanset, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspanset, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(intspanset, intspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(bigint, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspan, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspanset, bigint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspanset, bigintspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(bigintspanset, bigintspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(float, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspan, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspanset, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspanset, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(floatspanset, floatspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(date, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespan, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespanset, date) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespanset, datespan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(datespanset, datespanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +CREATE FUNCTION span_adjacent(timestamptz, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspan, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspanset, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspanset, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_adjacent(tstzspanset, tstzspanset) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = span_adjacent, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = -|-, + RESTRICT = span_sel, JOIN = span_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION span_union(integer, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspan, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspanset, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspanset, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(intspanset, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Union_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(bigint, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspan, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspanset, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspanset, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(bigintspanset, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Union_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(float, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspan, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspanset, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspanset, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(floatspanset, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Union_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(date, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespan, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespanset, date) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespanset, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(datespanset, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Union_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = + +); + +CREATE FUNCTION span_union(timestamptz, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspan, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspanset, timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspanset, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_union(tstzspanset, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Union_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = span_union, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = + +); + +/*****************************************************************************/ + +CREATE FUNCTION span_minus(integer, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspan, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspanset, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspanset, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(intspanset, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = integer, RIGHTARG = intspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspan, RIGHTARG = intspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspanset, RIGHTARG = integer +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspanset, RIGHTARG = intspan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = intspanset, RIGHTARG = intspanset +); + +CREATE FUNCTION span_minus(bigint, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspan, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspanset, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspanset, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(bigintspanset, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigint, RIGHTARG = bigintspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspan, RIGHTARG = bigintspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspanset, RIGHTARG = bigint +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspanset, RIGHTARG = bigintspan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset +); + +CREATE FUNCTION span_minus(float, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspan, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspanset, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspanset, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(floatspanset, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = float, RIGHTARG = floatspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspan, RIGHTARG = floatspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspanset, RIGHTARG = float +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspanset, RIGHTARG = floatspan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = floatspanset, RIGHTARG = floatspanset +); + +CREATE FUNCTION span_minus(date, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespan, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespanset, date) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespanset, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(datespanset, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Minus_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = date, RIGHTARG = datespanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespan, RIGHTARG = datespanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespanset, RIGHTARG = date +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespanset, RIGHTARG = datespan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = datespanset, RIGHTARG = datespanset +); + +CREATE FUNCTION span_minus(timestamptz, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspan, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspanset, timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspanset, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_minus(tstzspanset, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Minus_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = timestamptz, RIGHTARG = tstzspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspan, RIGHTARG = tstzspanset +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspanset, RIGHTARG = timestamptz +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspanset, RIGHTARG = tstzspan +); +CREATE OPERATOR - ( + PROCEDURE = span_minus, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset +); + +/*****************************************************************************/ + +CREATE FUNCTION span_intersection(integer, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Intersection_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspan, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Intersection_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspanset, integer) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspanset, intspan) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(intspanset, intspanset) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(bigint, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Intersection_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspan, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Intersection_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspanset, bigint) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspanset, bigintspan) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(bigintspanset, bigintspanset) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(float, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intersection_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspan, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intersection_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspanset, float) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspanset, floatspan) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(floatspanset, floatspanset) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(date, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Intersection_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespan, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Intersection_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespanset, date) + RETURNS date + AS 'MODULE_PATHNAME', 'Intersection_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespanset, datespan) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(datespanset, datespanset) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = * +); + +CREATE FUNCTION span_intersection(timestamptz, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Intersection_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspan, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Intersection_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspanset, timestamptz) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspanset, tstzspan) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_intersection(tstzspanset, tstzspanset) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Intersection_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = span_intersection, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = * +); + +/***************************************************************************** + * Distance operators + *****************************************************************************/ + +CREATE FUNCTION span_distance(integer, intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspan, intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspanset, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspanset, intspan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(intspanset, intspanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = integer, RIGHTARG = intspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspan, RIGHTARG = intspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspanset, RIGHTARG = integer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspanset, RIGHTARG = intspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = intspanset, RIGHTARG = intspanset, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(bigint, bigintspanset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspan, bigintspanset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspanset, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspanset, bigintspan) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(bigintspanset, bigintspanset) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Distance_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigint, RIGHTARG = bigintspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspan, RIGHTARG = bigintspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspanset, RIGHTARG = bigint, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspanset, RIGHTARG = bigintspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = bigintspanset, RIGHTARG = bigintspanset, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(float, floatspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspan, floatspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspanset, float) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspanset, floatspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(floatspanset, floatspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = float, RIGHTARG = floatspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspan, RIGHTARG = floatspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspanset, RIGHTARG = float, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspanset, RIGHTARG = floatspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = floatspanset, RIGHTARG = floatspanset, + COMMUTATOR = <-> +); + +CREATE FUNCTION span_distance(date, datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespan, datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespanset, date) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespanset, datespan) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_distance(datespanset, datespanset) + RETURNS integer + AS 'MODULE_PATHNAME', 'Distance_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = date, RIGHTARG = datespanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespan, RIGHTARG = datespanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespanset, RIGHTARG = date, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespanset, RIGHTARG = datespan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = span_distance, + LEFTARG = datespanset, RIGHTARG = datespanset, + COMMUTATOR = <-> +); + +CREATE FUNCTION time_distance(timestamptz, tstzspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_value_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION time_distance(tstzspan, tstzspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_span_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION time_distance(tstzspanset, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION time_distance(tstzspanset, tstzspan) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION time_distance(tstzspanset, tstzspanset) + RETURNS float + AS 'MODULE_PATHNAME', 'Distance_spanset_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = time_distance, + LEFTARG = timestamptz, RIGHTARG = tstzspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = time_distance, + LEFTARG = tstzspan, RIGHTARG = tstzspanset, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = time_distance, + LEFTARG = tstzspanset, RIGHTARG = timestamptz, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = time_distance, + LEFTARG = tstzspanset, RIGHTARG = tstzspan, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = time_distance, + LEFTARG = tstzspanset, RIGHTARG = tstzspanset, + COMMUTATOR = <-> +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/011_span_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/011_span_indexes.in.sql new file mode 100644 index 0000000..50ce819 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/011_span_indexes.in.sql @@ -0,0 +1,889 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST, Quad-tree SP-GiST, and Kd-tree SP-GiST indexes for span + * types + */ + +/****************************************************************************** + * R-tree GiST indexes + ******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, intspan, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_union(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_union' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_penalty(internal, internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_penalty' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_picksplit(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_same(intspan, intspan, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, intspan, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_fetch(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_fetch' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intspan_rtree_ops + DEFAULT FOR TYPE intspan USING gist AS + -- strictly left + OPERATOR 1 << (intspan, integer), + OPERATOR 1 << (intspan, intspan), + OPERATOR 1 << (intspan, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspan, integer), + OPERATOR 2 &< (intspan, intspan), + OPERATOR 2 &< (intspan, intspanset), + -- overlaps + OPERATOR 3 && (intspan, intspan), + OPERATOR 3 && (intspan, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspan, integer), + OPERATOR 4 &> (intspan, intspan), + OPERATOR 4 &> (intspan, intspanset), + -- strictly right + OPERATOR 5 >> (intspan, integer), + OPERATOR 5 >> (intspan, intspan), + OPERATOR 5 >> (intspan, intspanset), + -- contains + OPERATOR 7 @> (intspan, integer), + OPERATOR 7 @> (intspan, intspan), + OPERATOR 7 @> (intspan, intspanset), + -- contained by + OPERATOR 8 <@ (intspan, intspan), + OPERATOR 8 <@ (intspan, intspanset), + -- adjacent + OPERATOR 17 -|- (intspan, intspan), + OPERATOR 17 -|- (intspan, intspanset), + -- equals + OPERATOR 18 = (intspan, intspan), + -- nearest approach distance + OPERATOR 25 <-> (intspan, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, intspan, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(intspan, intspan, internal), + FUNCTION 8 span_gist_distance(internal, intspan, smallint, oid, internal), + FUNCTION 9 span_gist_fetch(internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, bigintspan, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_same(bigintspan, bigintspan, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, bigintspan, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspan_rtree_ops + DEFAULT FOR TYPE bigintspan USING gist AS + -- strictly left + OPERATOR 1 << (bigintspan, bigint), + OPERATOR 1 << (bigintspan, bigintspan), + OPERATOR 1 << (bigintspan, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspan, bigint), + OPERATOR 2 &< (bigintspan, bigintspan), + OPERATOR 2 &< (bigintspan, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspan, bigintspan), + OPERATOR 3 && (bigintspan, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspan, bigint), + OPERATOR 4 &> (bigintspan, bigintspan), + OPERATOR 4 &> (bigintspan, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspan, bigint), + OPERATOR 5 >> (bigintspan, bigintspan), + OPERATOR 5 >> (bigintspan, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspan, bigint), + OPERATOR 7 @> (bigintspan, bigintspan), + OPERATOR 7 @> (bigintspan, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspan, bigintspan), + OPERATOR 8 <@ (bigintspan, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspan, bigintspan), + OPERATOR 17 -|- (bigintspan, bigintspanset), + -- equals + OPERATOR 18 = (bigintspan, bigintspan), + -- nearest approach distance + OPERATOR 25 <-> (bigintspan, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, bigintspan, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(bigintspan, bigintspan, internal), + FUNCTION 8 span_gist_distance(internal, bigintspan, smallint, oid, internal), + FUNCTION 9 span_gist_fetch(internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, floatspan, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_same(floatspan, floatspan, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, floatspan, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspan_rtree_ops + DEFAULT FOR TYPE floatspan USING gist AS + -- strictly left + OPERATOR 1 << (floatspan, float), + OPERATOR 1 << (floatspan, floatspan), + OPERATOR 1 << (floatspan, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspan, float), + OPERATOR 2 &< (floatspan, floatspan), + OPERATOR 2 &< (floatspan, floatspanset), + -- overlaps + OPERATOR 3 && (floatspan, floatspan), + OPERATOR 3 && (floatspan, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspan, float), + OPERATOR 4 &> (floatspan, floatspan), + OPERATOR 4 &> (floatspan, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspan, float), + OPERATOR 5 >> (floatspan, floatspan), + OPERATOR 5 >> (floatspan, floatspanset), + -- contains + OPERATOR 7 @> (floatspan, float), + OPERATOR 7 @> (floatspan, floatspan), + OPERATOR 7 @> (floatspan, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspan, floatspan), + OPERATOR 8 <@ (floatspan, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspan, floatspan), + OPERATOR 17 -|- (floatspan, floatspanset), + -- equals + OPERATOR 18 = (floatspan, floatspan), + -- nearest approach distance + OPERATOR 25 <-> (floatspan, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, floatspan, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(floatspan, floatspan, internal), + FUNCTION 8 span_gist_distance(internal, floatspan, smallint, oid, internal), + FUNCTION 9 span_gist_fetch(internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, datespan, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_same(datespan, datespan, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, datespan, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespan_rtree_ops + DEFAULT FOR TYPE datespan USING gist AS + -- strictly left + OPERATOR 1 <<# (datespan, date), + OPERATOR 1 <<# (datespan, datespan), + OPERATOR 1 <<# (datespan, datespanset), + -- overlaps or left + OPERATOR 2 &<# (datespan, date), + OPERATOR 2 &<# (datespan, datespan), + OPERATOR 2 &<# (datespan, datespanset), + -- overlaps + OPERATOR 3 && (datespan, datespan), + OPERATOR 3 && (datespan, datespanset), + -- overlaps or right + OPERATOR 4 #&> (datespan, date), + OPERATOR 4 #&> (datespan, datespan), + OPERATOR 4 #&> (datespan, datespanset), + -- strictly right + OPERATOR 5 #>> (datespan, date), + OPERATOR 5 #>> (datespan, datespan), + OPERATOR 5 #>> (datespan, datespanset), + -- contains + OPERATOR 7 @> (datespan, date), + OPERATOR 7 @> (datespan, datespan), + OPERATOR 7 @> (datespan, datespanset), + -- contained by + OPERATOR 8 <@ (datespan, datespan), + OPERATOR 8 <@ (datespan, datespanset), + -- adjacent + OPERATOR 17 -|- (datespan, datespan), + OPERATOR 17 -|- (datespan, datespanset), + -- equals + OPERATOR 18 = (datespan, datespan), + -- nearest approach distance + OPERATOR 25 <-> (datespan, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, datespan, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(datespan, datespan, internal), + FUNCTION 8 span_gist_distance(internal, datespan, smallint, oid, internal), + FUNCTION 9 span_gist_fetch(internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, tstzspan, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_same(tstzspan, tstzspan, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, tstzspan, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspan_rtree_ops + DEFAULT FOR TYPE tstzspan USING gist AS + -- overlaps + OPERATOR 3 && (tstzspan, tstzspan), + OPERATOR 3 && (tstzspan, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspan, timestamptz), + OPERATOR 7 @> (tstzspan, tstzspan), + OPERATOR 7 @> (tstzspan, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspan, tstzspan), + OPERATOR 8 <@ (tstzspan, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspan, tstzspan), + OPERATOR 17 -|- (tstzspan, tstzspanset), + -- equals + OPERATOR 18 = (tstzspan, tstzspan), + -- nearest approach distance + OPERATOR 25 <-> (tstzspan, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspan, timestamptz), + OPERATOR 28 &<# (tstzspan, tstzspan), + OPERATOR 28 &<# (tstzspan, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspan, timestamptz), + OPERATOR 29 <<# (tstzspan, tstzspan), + OPERATOR 29 <<# (tstzspan, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspan, timestamptz), + OPERATOR 30 #>> (tstzspan, tstzspan), + OPERATOR 30 #>> (tstzspan, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspan, timestamptz), + OPERATOR 31 #&> (tstzspan, tstzspan), + OPERATOR 31 #&> (tstzspan, tstzspanset), + -- functions + FUNCTION 1 span_gist_consistent(internal, tstzspan, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(tstzspan, tstzspan, internal), + FUNCTION 8 span_gist_distance(internal, tstzspan, smallint, oid, internal), + FUNCTION 9 span_gist_fetch(internal); + +/****************************************************************************** + * Quad-tree SP-GiST indexes + ******************************************************************************/ + +CREATE FUNCTION intspan_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Intspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintspan_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Bigintspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Floatspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION datespan_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Datespan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tstzspan_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tstzspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION span_quadtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_quadtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_quadtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_quadtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_quadtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_quadtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_spgist_leaf_consistent(internal, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_spgist_leaf_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intspan_quadtree_ops + DEFAULT FOR TYPE intspan USING spgist AS + -- strictly left + OPERATOR 1 << (intspan, integer), + OPERATOR 1 << (intspan, intspan), + OPERATOR 1 << (intspan, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspan, integer), + OPERATOR 2 &< (intspan, intspan), + OPERATOR 2 &< (intspan, intspanset), + -- overlaps + OPERATOR 3 && (intspan, intspan), + OPERATOR 3 && (intspan, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspan, integer), + OPERATOR 4 &> (intspan, intspan), + OPERATOR 4 &> (intspan, intspanset), + -- strictly right + OPERATOR 5 >> (intspan, integer), + OPERATOR 5 >> (intspan, intspan), + OPERATOR 5 >> (intspan, intspanset), + -- contains + OPERATOR 7 @> (intspan, integer), + OPERATOR 7 @> (intspan, intspan), + OPERATOR 7 @> (intspan, intspanset), + -- contained by + OPERATOR 8 <@ (intspan, intspan), + OPERATOR 8 <@ (intspan, intspanset), + -- adjacent + OPERATOR 17 -|- (intspan, intspan), + OPERATOR 17 -|- (intspan, intspanset), + -- equals + OPERATOR 18 = (intspan, intspan), + -- nearest approach distance + OPERATOR 25 <-> (intspan, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspan_quadtree_ops + DEFAULT FOR TYPE bigintspan USING spgist AS + -- strictly left + OPERATOR 1 << (bigintspan, bigint), + OPERATOR 1 << (bigintspan, bigintspan), + OPERATOR 1 << (bigintspan, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspan, bigint), + OPERATOR 2 &< (bigintspan, bigintspan), + OPERATOR 2 &< (bigintspan, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspan, bigintspan), + OPERATOR 3 && (bigintspan, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspan, bigint), + OPERATOR 4 &> (bigintspan, bigintspan), + OPERATOR 4 &> (bigintspan, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspan, bigint), + OPERATOR 5 >> (bigintspan, bigintspan), + OPERATOR 5 >> (bigintspan, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspan, bigint), + OPERATOR 7 @> (bigintspan, bigintspan), + OPERATOR 7 @> (bigintspan, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspan, bigintspan), + OPERATOR 8 <@ (bigintspan, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspan, bigintspan), + OPERATOR 17 -|- (bigintspan, bigintspanset), + -- equals + OPERATOR 18 = (bigintspan, bigintspan), + -- nearest approach distance + OPERATOR 25 <-> (bigintspan, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 bigintspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspan_quadtree_ops + DEFAULT FOR TYPE floatspan USING spgist AS + -- strictly left + OPERATOR 1 << (floatspan, float), + OPERATOR 1 << (floatspan, floatspan), + OPERATOR 1 << (floatspan, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspan, float), + OPERATOR 2 &< (floatspan, floatspan), + OPERATOR 2 &< (floatspan, floatspanset), + -- overlaps + OPERATOR 3 && (floatspan, floatspan), + OPERATOR 3 && (floatspan, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspan, float), + OPERATOR 4 &> (floatspan, floatspan), + OPERATOR 4 &> (floatspan, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspan, float), + OPERATOR 5 >> (floatspan, floatspan), + OPERATOR 5 >> (floatspan, floatspanset), + -- contains + OPERATOR 7 @> (floatspan, float), + OPERATOR 7 @> (floatspan, floatspan), + OPERATOR 7 @> (floatspan, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspan, floatspan), + OPERATOR 8 <@ (floatspan, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspan, floatspan), + OPERATOR 17 -|- (floatspan, floatspanset), + -- equals + OPERATOR 18 = (floatspan, floatspan), + -- nearest approach distance + OPERATOR 25 <-> (floatspan, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespan_quadtree_ops + DEFAULT FOR TYPE datespan USING spgist AS + -- overlaps + OPERATOR 3 && (datespan, datespan), + OPERATOR 3 && (datespan, datespanset), + -- contains + OPERATOR 7 @> (datespan, date), + OPERATOR 7 @> (datespan, datespan), + OPERATOR 7 @> (datespan, datespanset), + -- contained by + OPERATOR 8 <@ (datespan, datespan), + OPERATOR 8 <@ (datespan, datespanset), + -- adjacent + OPERATOR 17 -|- (datespan, datespan), + OPERATOR 17 -|- (datespan, datespanset), + -- equals + OPERATOR 18 = (datespan, datespan), + -- nearest approach distance + OPERATOR 25 <-> (datespan, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (datespan, date), + OPERATOR 28 &<# (datespan, datespan), + OPERATOR 28 &<# (datespan, datespanset), + -- strictly before + OPERATOR 29 <<# (datespan, date), + OPERATOR 29 <<# (datespan, datespan), + OPERATOR 29 <<# (datespan, datespanset), + -- strictly after + OPERATOR 30 #>> (datespan, date), + OPERATOR 30 #>> (datespan, datespan), + OPERATOR 30 #>> (datespan, datespanset), + -- overlaps or after + OPERATOR 31 #&> (datespan, date), + OPERATOR 31 #&> (datespan, datespan), + OPERATOR 31 #&> (datespan, datespanset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspan_quadtree_ops + DEFAULT FOR TYPE tstzspan USING spgist AS + -- overlaps + OPERATOR 3 && (tstzspan, tstzspan), + OPERATOR 3 && (tstzspan, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspan, timestamptz), + OPERATOR 7 @> (tstzspan, tstzspan), + OPERATOR 7 @> (tstzspan, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspan, tstzspan), + OPERATOR 8 <@ (tstzspan, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspan, tstzspan), + OPERATOR 17 -|- (tstzspan, tstzspanset), + -- equals + OPERATOR 18 = (tstzspan, tstzspan), + -- nearest approach distance + OPERATOR 25 <-> (tstzspan, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspan, timestamptz), + OPERATOR 28 &<# (tstzspan, tstzspan), + OPERATOR 28 &<# (tstzspan, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspan, timestamptz), + OPERATOR 29 <<# (tstzspan, tstzspan), + OPERATOR 29 <<# (tstzspan, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspan, timestamptz), + OPERATOR 30 #>> (tstzspan, tstzspan), + OPERATOR 30 #>> (tstzspan, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspan, timestamptz), + OPERATOR 31 #&> (tstzspan, tstzspan), + OPERATOR 31 #&> (tstzspan, tstzspanset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/****************************************************************************** + * Kd-tree SP-GiST indexes + ******************************************************************************/ + +CREATE FUNCTION span_kdtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_kdtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_kdtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_kdtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_kdtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Span_kdtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intspan_kdtree_ops + FOR TYPE intspan USING spgist AS + -- strictly left + OPERATOR 1 << (intspan, integer), + OPERATOR 1 << (intspan, intspan), + OPERATOR 1 << (intspan, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspan, integer), + OPERATOR 2 &< (intspan, intspan), + OPERATOR 2 &< (intspan, intspanset), + -- overlaps + OPERATOR 3 && (intspan, intspan), + OPERATOR 3 && (intspan, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspan, integer), + OPERATOR 4 &> (intspan, intspan), + OPERATOR 4 &> (intspan, intspanset), + -- strictly right + OPERATOR 5 >> (intspan, integer), + OPERATOR 5 >> (intspan, intspan), + OPERATOR 5 >> (intspan, intspanset), + -- contains + OPERATOR 7 @> (intspan, integer), + OPERATOR 7 @> (intspan, intspan), + OPERATOR 7 @> (intspan, intspanset), + -- contained by + OPERATOR 8 <@ (intspan, intspan), + OPERATOR 8 <@ (intspan, intspanset), + -- adjacent + OPERATOR 17 -|- (intspan, intspan), + OPERATOR 17 -|- (intspan, intspanset), + -- equals + OPERATOR 18 = (intspan, intspan), + -- nearest approach distance + OPERATOR 25 <-> (intspan, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspan, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspan_kdtree_ops + FOR TYPE bigintspan USING spgist AS + -- strictly left + OPERATOR 1 << (bigintspan, bigint), + OPERATOR 1 << (bigintspan, bigintspan), + OPERATOR 1 << (bigintspan, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspan, bigint), + OPERATOR 2 &< (bigintspan, bigintspan), + OPERATOR 2 &< (bigintspan, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspan, bigintspan), + OPERATOR 3 && (bigintspan, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspan, bigint), + OPERATOR 4 &> (bigintspan, bigintspan), + OPERATOR 4 &> (bigintspan, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspan, bigint), + OPERATOR 5 >> (bigintspan, bigintspan), + OPERATOR 5 >> (bigintspan, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspan, bigint), + OPERATOR 7 @> (bigintspan, bigintspan), + OPERATOR 7 @> (bigintspan, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspan, bigintspan), + OPERATOR 8 <@ (bigintspan, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspan, bigintspan), + OPERATOR 17 -|- (bigintspan, bigintspanset), + -- equals + OPERATOR 18 = (bigintspan, bigintspan), + -- nearest approach distance + OPERATOR 25 <-> (bigintspan, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspan, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 bigintspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspan_kdtree_ops + FOR TYPE floatspan USING spgist AS + -- strictly left + OPERATOR 1 << (floatspan, float), + OPERATOR 1 << (floatspan, floatspan), + OPERATOR 1 << (floatspan, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspan, float), + OPERATOR 2 &< (floatspan, floatspan), + OPERATOR 2 &< (floatspan, floatspanset), + -- overlaps + OPERATOR 3 && (floatspan, floatspan), + OPERATOR 3 && (floatspan, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspan, float), + OPERATOR 4 &> (floatspan, floatspan), + OPERATOR 4 &> (floatspan, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspan, float), + OPERATOR 5 >> (floatspan, floatspan), + OPERATOR 5 >> (floatspan, floatspanset), + -- contains + OPERATOR 7 @> (floatspan, float), + OPERATOR 7 @> (floatspan, floatspan), + OPERATOR 7 @> (floatspan, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspan, floatspan), + OPERATOR 8 <@ (floatspan, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspan, floatspan), + OPERATOR 17 -|- (floatspan, floatspanset), + -- equals + OPERATOR 18 = (floatspan, floatspan), + -- nearest approach distance + OPERATOR 25 <-> (floatspan, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspan, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespan_kdtree_ops + FOR TYPE datespan USING spgist AS + -- overlaps + OPERATOR 3 && (datespan, datespan), + OPERATOR 3 && (datespan, datespanset), + -- contains + OPERATOR 7 @> (datespan, date), + OPERATOR 7 @> (datespan, datespan), + OPERATOR 7 @> (datespan, datespanset), + -- contained by + OPERATOR 8 <@ (datespan, datespan), + OPERATOR 8 <@ (datespan, datespanset), + -- adjacent + OPERATOR 17 -|- (datespan, datespan), + OPERATOR 17 -|- (datespan, datespanset), + -- equals + OPERATOR 18 = (datespan, datespan), + -- nearest approach distance + OPERATOR 25 <-> (datespan, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespan, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (datespan, date), + OPERATOR 28 &<# (datespan, datespan), + OPERATOR 28 &<# (datespan, datespanset), + -- strictly before + OPERATOR 29 <<# (datespan, date), + OPERATOR 29 <<# (datespan, datespan), + OPERATOR 29 <<# (datespan, datespanset), + -- strictly after + OPERATOR 30 #>> (datespan, date), + OPERATOR 30 #>> (datespan, datespan), + OPERATOR 30 #>> (datespan, datespanset), + -- overlaps or after + OPERATOR 31 #&> (datespan, date), + OPERATOR 31 #&> (datespan, datespan), + OPERATOR 31 #&> (datespan, datespanset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspan_kdtree_ops + FOR TYPE tstzspan USING spgist AS + -- overlaps + OPERATOR 3 && (tstzspan, tstzspan), + OPERATOR 3 && (tstzspan, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspan, timestamptz), + OPERATOR 7 @> (tstzspan, tstzspan), + OPERATOR 7 @> (tstzspan, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspan, tstzspan), + OPERATOR 8 <@ (tstzspan, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspan, tstzspan), + OPERATOR 17 -|- (tstzspan, tstzspanset), + -- equals + OPERATOR 18 = (tstzspan, tstzspan), + -- nearest approach distance + OPERATOR 25 <-> (tstzspan, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspan, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspan, timestamptz), + OPERATOR 28 &<# (tstzspan, tstzspan), + OPERATOR 28 &<# (tstzspan, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspan, timestamptz), + OPERATOR 29 <<# (tstzspan, tstzspan), + OPERATOR 29 <<# (tstzspan, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspan, timestamptz), + OPERATOR 30 #>> (tstzspan, tstzspan), + OPERATOR 30 #>> (tstzspan, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspan, timestamptz), + OPERATOR 31 #&> (tstzspan, tstzspan), + OPERATOR 31 #&> (tstzspan, tstzspanset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/012_spanset_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/012_spanset_indexes.in.sql new file mode 100644 index 0000000..806570f --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/012_spanset_indexes.in.sql @@ -0,0 +1,789 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST and Quad-tree SP-GiST, and Kd-tree SP-GiST indexes for + * span set types + */ + +/****************************************************************************** + * R-tree GiST indexes + ******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, intspanset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_consistent(internal, bigintspanset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_consistent(internal, floatspanset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_consistent(internal, datespanset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_consistent(internal, tstzspanset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spanset_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intspanset_rtree_ops + DEFAULT FOR TYPE intspanset USING gist AS + STORAGE intspan, + -- strictly left + OPERATOR 1 << (intspanset, integer), + OPERATOR 1 << (intspanset, intspan), + OPERATOR 1 << (intspanset, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspanset, integer), + OPERATOR 2 &< (intspanset, intspan), + OPERATOR 2 &< (intspanset, intspanset), + -- overlaps + OPERATOR 3 && (intspanset, intspan), + OPERATOR 3 && (intspanset, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspanset, integer), + OPERATOR 4 &> (intspanset, intspan), + OPERATOR 4 &> (intspanset, intspanset), + -- strictly right + OPERATOR 5 >> (intspanset, integer), + OPERATOR 5 >> (intspanset, intspan), + OPERATOR 5 >> (intspanset, intspanset), + -- contains + OPERATOR 7 @> (intspanset, integer), + OPERATOR 7 @> (intspanset, intspan), + OPERATOR 7 @> (intspanset, intspanset), + -- contained by + OPERATOR 8 <@ (intspanset, intspan), + OPERATOR 8 <@ (intspanset, intspanset), + -- adjacent + OPERATOR 17 -|- (intspanset, intspan), + OPERATOR 17 -|- (intspanset, intspanset), + -- equals + OPERATOR 18 = (intspanset, intspanset), + -- nearest approach distance + OPERATOR 25 <-> (intspanset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, intspanset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 spanset_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(intspan, intspan, internal), + FUNCTION 8 span_gist_distance(internal, intspan, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspanset_rtree_ops + DEFAULT FOR TYPE bigintspanset USING gist AS + STORAGE bigintspan, + -- strictly left + OPERATOR 1 << (bigintspanset, bigint), + OPERATOR 1 << (bigintspanset, bigintspan), + OPERATOR 1 << (bigintspanset, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspanset, bigint), + OPERATOR 2 &< (bigintspanset, bigintspan), + OPERATOR 2 &< (bigintspanset, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspanset, bigintspan), + OPERATOR 3 && (bigintspanset, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspanset, bigint), + OPERATOR 4 &> (bigintspanset, bigintspan), + OPERATOR 4 &> (bigintspanset, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspanset, bigint), + OPERATOR 5 >> (bigintspanset, bigintspan), + OPERATOR 5 >> (bigintspanset, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspanset, bigint), + OPERATOR 7 @> (bigintspanset, bigintspan), + OPERATOR 7 @> (bigintspanset, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspanset, bigintspan), + OPERATOR 8 <@ (bigintspanset, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspanset, bigintspan), + OPERATOR 17 -|- (bigintspanset, bigintspanset), + -- equals + OPERATOR 18 = (bigintspanset, bigintspanset), + -- nearest approach distance + OPERATOR 25 <-> (bigintspanset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, bigintspanset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 spanset_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(bigintspan, bigintspan, internal), + FUNCTION 8 span_gist_distance(internal, bigintspan, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspanset_rtree_ops + DEFAULT FOR TYPE floatspanset USING gist AS + STORAGE floatspan, + -- strictly left + OPERATOR 1 << (floatspanset, float), + OPERATOR 1 << (floatspanset, floatspan), + OPERATOR 1 << (floatspanset, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspanset, float), + OPERATOR 2 &< (floatspanset, floatspan), + OPERATOR 2 &< (floatspanset, floatspanset), + -- overlaps + OPERATOR 3 && (floatspanset, floatspan), + OPERATOR 3 && (floatspanset, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspanset, float), + OPERATOR 4 &> (floatspanset, floatspan), + OPERATOR 4 &> (floatspanset, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspanset, float), + OPERATOR 5 >> (floatspanset, floatspan), + OPERATOR 5 >> (floatspanset, floatspanset), + -- contains + OPERATOR 7 @> (floatspanset, float), + OPERATOR 7 @> (floatspanset, floatspan), + OPERATOR 7 @> (floatspanset, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspanset, floatspan), + OPERATOR 8 <@ (floatspanset, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspanset, floatspan), + OPERATOR 17 -|- (floatspanset, floatspanset), + -- equals + OPERATOR 18 = (floatspanset, floatspanset), + -- nearest approach distance + OPERATOR 25 <-> (floatspanset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, floatspanset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 spanset_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(floatspan, floatspan, internal), + FUNCTION 8 span_gist_distance(internal, floatspan, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespanset_rtree_ops + DEFAULT FOR TYPE datespanset USING gist AS + STORAGE datespan, + -- overlaps + OPERATOR 3 && (datespanset, datespan), + OPERATOR 3 && (datespanset, datespanset), + -- contains + OPERATOR 7 @> (datespanset, date), + OPERATOR 7 @> (datespanset, datespan), + OPERATOR 7 @> (datespanset, datespanset), + -- contained by + OPERATOR 8 <@ (datespanset, datespan), + OPERATOR 8 <@ (datespanset, datespanset), + -- adjacent + OPERATOR 17 -|- (datespanset, datespan), + OPERATOR 17 -|- (datespanset, datespanset), + -- equals + OPERATOR 18 = (datespanset, datespanset), + -- nearest approach distance + OPERATOR 25 <-> (datespanset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (datespanset, date), + OPERATOR 28 &<# (datespanset, datespan), + OPERATOR 28 &<# (datespanset, datespanset), + -- strictly before + OPERATOR 29 <<# (datespanset, date), + OPERATOR 29 <<# (datespanset, datespan), + OPERATOR 29 <<# (datespanset, datespanset), + -- strictly after + OPERATOR 30 #>> (datespanset, date), + OPERATOR 30 #>> (datespanset, datespan), + OPERATOR 30 #>> (datespanset, datespanset), + -- overlaps or after + OPERATOR 31 #&> (datespanset, date), + OPERATOR 31 #&> (datespanset, datespan), + OPERATOR 31 #&> (datespanset, datespanset), + -- functions + FUNCTION 1 span_gist_consistent(internal, datespanset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 spanset_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(datespan, datespan, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspanset_rtree_ops + DEFAULT FOR TYPE tstzspanset USING gist AS + STORAGE tstzspan, + -- overlaps + OPERATOR 3 && (tstzspanset, tstzspan), + OPERATOR 3 && (tstzspanset, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspanset, timestamptz), + OPERATOR 7 @> (tstzspanset, tstzspan), + OPERATOR 7 @> (tstzspanset, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspanset, tstzspan), + OPERATOR 8 <@ (tstzspanset, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspanset, tstzspan), + OPERATOR 17 -|- (tstzspanset, tstzspanset), + -- equals + OPERATOR 18 = (tstzspanset, tstzspanset), + -- nearest approach distance + OPERATOR 25 <-> (tstzspanset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspanset, timestamptz), + OPERATOR 28 &<# (tstzspanset, tstzspan), + OPERATOR 28 &<# (tstzspanset, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspanset, timestamptz), + OPERATOR 29 <<# (tstzspanset, tstzspan), + OPERATOR 29 <<# (tstzspanset, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspanset, timestamptz), + OPERATOR 30 #>> (tstzspanset, tstzspan), + OPERATOR 30 #>> (tstzspanset, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspanset, timestamptz), + OPERATOR 31 #&> (tstzspanset, tstzspan), + OPERATOR 31 #&> (tstzspanset, tstzspanset), + -- functions + FUNCTION 1 span_gist_consistent(internal, tstzspanset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 spanset_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(tstzspan, tstzspan, internal); + +/****************************************************************************** + * Quad-tree SP-GiST indexes + ******************************************************************************/ + +CREATE FUNCTION spanset_spgist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_spgist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intspanset_quadtree_ops + DEFAULT FOR TYPE intspanset USING spgist AS + -- strictly left + OPERATOR 1 << (intspanset, integer), + OPERATOR 1 << (intspanset, intspan), + OPERATOR 1 << (intspanset, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspanset, integer), + OPERATOR 2 &< (intspanset, intspan), + OPERATOR 2 &< (intspanset, intspanset), + -- overlaps + OPERATOR 3 && (intspanset, intspan), + OPERATOR 3 && (intspanset, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspanset, integer), + OPERATOR 4 &> (intspanset, intspan), + OPERATOR 4 &> (intspanset, intspanset), + -- strictly right + OPERATOR 5 >> (intspanset, integer), + OPERATOR 5 >> (intspanset, intspan), + OPERATOR 5 >> (intspanset, intspanset), + -- contains + OPERATOR 7 @> (intspanset, integer), + OPERATOR 7 @> (intspanset, intspan), + OPERATOR 7 @> (intspanset, intspanset), + -- contained by + OPERATOR 8 <@ (intspanset, intspan), + OPERATOR 8 <@ (intspanset, intspanset), + -- adjacent + OPERATOR 17 -|- (intspanset, intspan), + OPERATOR 17 -|- (intspanset, intspanset), + -- equals + OPERATOR 18 = (intspanset, intspanset), + -- nearest approach distance + OPERATOR 25 <-> (intspanset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspanset_quadtree_ops + DEFAULT FOR TYPE bigintspanset USING spgist AS + -- strictly left + OPERATOR 1 << (bigintspanset, bigint), + OPERATOR 1 << (bigintspanset, bigintspan), + OPERATOR 1 << (bigintspanset, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspanset, bigint), + OPERATOR 2 &< (bigintspanset, bigintspan), + OPERATOR 2 &< (bigintspanset, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspanset, bigintspan), + OPERATOR 3 && (bigintspanset, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspanset, bigint), + OPERATOR 4 &> (bigintspanset, bigintspan), + OPERATOR 4 &> (bigintspanset, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspanset, bigint), + OPERATOR 5 >> (bigintspanset, bigintspan), + OPERATOR 5 >> (bigintspanset, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspanset, bigint), + OPERATOR 7 @> (bigintspanset, bigintspan), + OPERATOR 7 @> (bigintspanset, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspanset, bigintspan), + OPERATOR 8 <@ (bigintspanset, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspanset, bigintspan), + OPERATOR 17 -|- (bigintspanset, bigintspanset), + -- equals + OPERATOR 18 = (bigintspanset, bigintspanset), + -- nearest approach distance + OPERATOR 25 <-> (bigintspanset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspanset_quadtree_ops + DEFAULT FOR TYPE floatspanset USING spgist AS + -- strictly left + OPERATOR 1 << (floatspanset, float), + OPERATOR 1 << (floatspanset, floatspan), + OPERATOR 1 << (floatspanset, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspanset, float), + OPERATOR 2 &< (floatspanset, floatspan), + OPERATOR 2 &< (floatspanset, floatspanset), + -- overlaps + OPERATOR 3 && (floatspanset, floatspan), + OPERATOR 3 && (floatspanset, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspanset, float), + OPERATOR 4 &> (floatspanset, floatspan), + OPERATOR 4 &> (floatspanset, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspanset, float), + OPERATOR 5 >> (floatspanset, floatspan), + OPERATOR 5 >> (floatspanset, floatspanset), + -- contains + OPERATOR 7 @> (floatspanset, float), + OPERATOR 7 @> (floatspanset, floatspan), + OPERATOR 7 @> (floatspanset, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspanset, floatspan), + OPERATOR 8 <@ (floatspanset, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspanset, floatspan), + OPERATOR 17 -|- (floatspanset, floatspanset), + -- equals + OPERATOR 18 = (floatspanset, floatspanset), + -- nearest approach distance + OPERATOR 25 <-> (floatspanset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespanset_quadtree_ops + DEFAULT FOR TYPE datespanset USING spgist AS + -- overlaps + OPERATOR 3 && (datespanset, datespan), + OPERATOR 3 && (datespanset, datespanset), + -- contains + OPERATOR 7 @> (datespanset, date), + OPERATOR 7 @> (datespanset, datespan), + OPERATOR 7 @> (datespanset, datespanset), + -- contained by + OPERATOR 8 <@ (datespanset, datespan), + OPERATOR 8 <@ (datespanset, datespanset), + -- adjacent + OPERATOR 17 -|- (datespanset, datespan), + OPERATOR 17 -|- (datespanset, datespanset), +-- equals + OPERATOR 18 = (datespanset, datespanset), + -- nearest approach distance + OPERATOR 25 <-> (datespanset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (datespanset, date), + OPERATOR 28 &<# (datespanset, datespan), + OPERATOR 28 &<# (datespanset, datespanset), + -- strictly before + OPERATOR 29 <<# (datespanset, date), + OPERATOR 29 <<# (datespanset, datespan), + OPERATOR 29 <<# (datespanset, datespanset), + -- strictly after + OPERATOR 30 #>> (datespanset, date), + OPERATOR 30 #>> (datespanset, datespan), + OPERATOR 30 #>> (datespanset, datespanset), + -- overlaps or after + OPERATOR 31 #&> (datespanset, date), + OPERATOR 31 #&> (datespanset, datespan), + OPERATOR 31 #&> (datespanset, datespanset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspanset_quadtree_ops + DEFAULT FOR TYPE tstzspanset USING spgist AS + -- overlaps + OPERATOR 3 && (tstzspanset, tstzspan), + OPERATOR 3 && (tstzspanset, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspanset, timestamptz), + OPERATOR 7 @> (tstzspanset, tstzspan), + OPERATOR 7 @> (tstzspanset, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspanset, tstzspan), + OPERATOR 8 <@ (tstzspanset, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspanset, tstzspan), + OPERATOR 17 -|- (tstzspanset, tstzspanset), +-- equals + OPERATOR 18 = (tstzspanset, tstzspanset), + -- nearest approach distance + OPERATOR 25 <-> (tstzspanset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspanset, timestamptz), + OPERATOR 28 &<# (tstzspanset, tstzspan), + OPERATOR 28 &<# (tstzspanset, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspanset, timestamptz), + OPERATOR 29 <<# (tstzspanset, tstzspan), + OPERATOR 29 <<# (tstzspanset, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspanset, timestamptz), + OPERATOR 30 #>> (tstzspanset, tstzspan), + OPERATOR 30 #>> (tstzspanset, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspanset, timestamptz), + OPERATOR 31 #&> (tstzspanset, tstzspan), + OPERATOR 31 #&> (tstzspanset, tstzspanset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/****************************************************************************** + * Kd-tree SP-GiST indexes + ******************************************************************************/ + +CREATE OPERATOR CLASS intspanset_kdtree_ops + FOR TYPE intspanset USING spgist AS + -- strictly left + OPERATOR 1 << (intspanset, integer), + OPERATOR 1 << (intspanset, intspan), + OPERATOR 1 << (intspanset, intspanset), + -- overlaps or left + OPERATOR 2 &< (intspanset, integer), + OPERATOR 2 &< (intspanset, intspan), + OPERATOR 2 &< (intspanset, intspanset), + -- overlaps + OPERATOR 3 && (intspanset, intspan), + OPERATOR 3 && (intspanset, intspanset), + -- overlaps or right + OPERATOR 4 &> (intspanset, integer), + OPERATOR 4 &> (intspanset, intspan), + OPERATOR 4 &> (intspanset, intspanset), + -- strictly right + OPERATOR 5 >> (intspanset, integer), + OPERATOR 5 >> (intspanset, intspan), + OPERATOR 5 >> (intspanset, intspanset), + -- contains + OPERATOR 7 @> (intspanset, integer), + OPERATOR 7 @> (intspanset, intspan), + OPERATOR 7 @> (intspanset, intspanset), + -- contained by + OPERATOR 8 <@ (intspanset, intspan), + OPERATOR 8 <@ (intspanset, intspanset), + -- adjacent + OPERATOR 17 -|- (intspanset, intspan), + OPERATOR 17 -|- (intspanset, intspanset), + -- equals + OPERATOR 18 = (intspanset, intspanset), + -- nearest approach distance + OPERATOR 25 <-> (intspanset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intspanset, intspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintspanset_kdtree_ops + FOR TYPE bigintspanset USING spgist AS + -- strictly left + OPERATOR 1 << (bigintspanset, bigint), + OPERATOR 1 << (bigintspanset, bigintspan), + OPERATOR 1 << (bigintspanset, bigintspanset), + -- overlaps or left + OPERATOR 2 &< (bigintspanset, bigint), + OPERATOR 2 &< (bigintspanset, bigintspan), + OPERATOR 2 &< (bigintspanset, bigintspanset), + -- overlaps + OPERATOR 3 && (bigintspanset, bigintspan), + OPERATOR 3 && (bigintspanset, bigintspanset), + -- overlaps or right + OPERATOR 4 &> (bigintspanset, bigint), + OPERATOR 4 &> (bigintspanset, bigintspan), + OPERATOR 4 &> (bigintspanset, bigintspanset), + -- strictly right + OPERATOR 5 >> (bigintspanset, bigint), + OPERATOR 5 >> (bigintspanset, bigintspan), + OPERATOR 5 >> (bigintspanset, bigintspanset), + -- contains + OPERATOR 7 @> (bigintspanset, bigint), + OPERATOR 7 @> (bigintspanset, bigintspan), + OPERATOR 7 @> (bigintspanset, bigintspanset), + -- contained by + OPERATOR 8 <@ (bigintspanset, bigintspan), + OPERATOR 8 <@ (bigintspanset, bigintspanset), + -- adjacent + OPERATOR 17 -|- (bigintspanset, bigintspan), + OPERATOR 17 -|- (bigintspanset, bigintspanset), + -- equals + OPERATOR 18 = (bigintspanset, bigintspanset), + -- nearest approach distance + OPERATOR 25 <-> (bigintspanset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintspanset, bigintspanset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatspanset_kdtree_ops + FOR TYPE floatspanset USING spgist AS + -- strictly left + OPERATOR 1 << (floatspanset, float), + OPERATOR 1 << (floatspanset, floatspan), + OPERATOR 1 << (floatspanset, floatspanset), + -- overlaps or left + OPERATOR 2 &< (floatspanset, float), + OPERATOR 2 &< (floatspanset, floatspan), + OPERATOR 2 &< (floatspanset, floatspanset), + -- overlaps + OPERATOR 3 && (floatspanset, floatspan), + OPERATOR 3 && (floatspanset, floatspanset), + -- overlaps or right + OPERATOR 4 &> (floatspanset, float), + OPERATOR 4 &> (floatspanset, floatspan), + OPERATOR 4 &> (floatspanset, floatspanset), + -- strictly right + OPERATOR 5 >> (floatspanset, float), + OPERATOR 5 >> (floatspanset, floatspan), + OPERATOR 5 >> (floatspanset, floatspanset), + -- contains + OPERATOR 7 @> (floatspanset, float), + OPERATOR 7 @> (floatspanset, floatspan), + OPERATOR 7 @> (floatspanset, floatspanset), + -- contained by + OPERATOR 8 <@ (floatspanset, floatspan), + OPERATOR 8 <@ (floatspanset, floatspanset), + -- adjacent + OPERATOR 17 -|- (floatspanset, floatspan), + OPERATOR 17 -|- (floatspanset, floatspanset), + -- equals + OPERATOR 18 = (floatspanset, floatspanset), + -- nearest approach distance + OPERATOR 25 <-> (floatspanset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatspanset, floatspanset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS datespanset_kdtree_ops + FOR TYPE datespanset USING spgist AS + -- overlaps + OPERATOR 3 && (datespanset, datespan), + OPERATOR 3 && (datespanset, datespanset), + -- contains + OPERATOR 7 @> (datespanset, date), + OPERATOR 7 @> (datespanset, datespan), + OPERATOR 7 @> (datespanset, datespanset), + -- contained by + OPERATOR 8 <@ (datespanset, datespan), + OPERATOR 8 <@ (datespanset, datespanset), + -- adjacent + OPERATOR 17 -|- (datespanset, datespan), + OPERATOR 17 -|- (datespanset, datespanset), +-- equals + OPERATOR 18 = (datespanset, datespanset), + -- nearest approach distance + OPERATOR 25 <-> (datespanset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespan) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (datespanset, datespanset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (datespanset, date), + OPERATOR 28 &<# (datespanset, datespan), + OPERATOR 28 &<# (datespanset, datespanset), + -- strictly before + OPERATOR 29 <<# (datespanset, date), + OPERATOR 29 <<# (datespanset, datespan), + OPERATOR 29 <<# (datespanset, datespanset), + -- strictly after + OPERATOR 30 #>> (datespanset, date), + OPERATOR 30 #>> (datespanset, datespan), + OPERATOR 30 #>> (datespanset, datespanset), + -- overlaps or after + OPERATOR 31 #&> (datespanset, date), + OPERATOR 31 #&> (datespanset, datespan), + OPERATOR 31 #&> (datespanset, datespanset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzspanset_kdtree_ops + FOR TYPE tstzspanset USING spgist AS + -- overlaps + OPERATOR 3 && (tstzspanset, tstzspan), + OPERATOR 3 && (tstzspanset, tstzspanset), + -- contains + OPERATOR 7 @> (tstzspanset, timestamptz), + OPERATOR 7 @> (tstzspanset, tstzspan), + OPERATOR 7 @> (tstzspanset, tstzspanset), + -- contained by + OPERATOR 8 <@ (tstzspanset, tstzspan), + OPERATOR 8 <@ (tstzspanset, tstzspanset), + -- adjacent + OPERATOR 17 -|- (tstzspanset, tstzspan), + OPERATOR 17 -|- (tstzspanset, tstzspanset), +-- equals + OPERATOR 18 = (tstzspanset, tstzspanset), + -- nearest approach distance + OPERATOR 25 <-> (tstzspanset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspan) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzspanset, tstzspanset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzspanset, timestamptz), + OPERATOR 28 &<# (tstzspanset, tstzspan), + OPERATOR 28 &<# (tstzspanset, tstzspanset), + -- strictly before + OPERATOR 29 <<# (tstzspanset, timestamptz), + OPERATOR 29 <<# (tstzspanset, tstzspan), + OPERATOR 29 <<# (tstzspanset, tstzspanset), + -- strictly after + OPERATOR 30 #>> (tstzspanset, timestamptz), + OPERATOR 30 #>> (tstzspanset, tstzspan), + OPERATOR 30 #>> (tstzspanset, tstzspanset), + -- overlaps or after + OPERATOR 31 #&> (tstzspanset, timestamptz), + OPERATOR 31 #&> (tstzspanset, tstzspan), + OPERATOR 31 #&> (tstzspanset, tstzspanset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 spanset_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/013_set_indexes.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/013_set_indexes.in.sql new file mode 100644 index 0000000..a1869c6 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/013_set_indexes.in.sql @@ -0,0 +1,774 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST, Quad-tree SP-GiST, and Kd-tree SP-GiST indexes for set + * types + */ + +/****************************************************************************** + * R-tree GiST indexes + ******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, intset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, intset, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intset_rtree_ops + DEFAULT FOR TYPE intset USING gist AS + STORAGE intspan, + -- strictly left + OPERATOR 1 << (intset, integer), + OPERATOR 1 << (intset, intset), + -- overlaps or left + OPERATOR 2 &< (intset, integer), + OPERATOR 2 &< (intset, intset), + -- overlaps + OPERATOR 3 && (intset, intset), + -- overlaps or right + OPERATOR 4 &> (intset, integer), + OPERATOR 4 &> (intset, intset), + -- strictly right + OPERATOR 5 >> (intset, integer), + OPERATOR 5 >> (intset, intset), + -- contains + OPERATOR 7 @> (intset, integer), + OPERATOR 7 @> (intset, intset), + -- contained by + OPERATOR 8 <@ (intset, intset), + -- equals + OPERATOR 18 = (intset, intset), + -- nearest approach distance + OPERATOR 25 <-> (intset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intset, intset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, intset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 set_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(intspan, intspan, internal), + FUNCTION 8 span_gist_distance(internal, intset, smallint, oid, internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, bigintset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, bigintset, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintset_rtree_ops + DEFAULT FOR TYPE bigintset USING gist AS + STORAGE bigintspan, + -- strictly left + OPERATOR 1 << (bigintset, bigint), + OPERATOR 1 << (bigintset, bigintset), + -- overlaps or left + OPERATOR 2 &< (bigintset, bigint), + OPERATOR 2 &< (bigintset, bigintset), + -- overlaps + OPERATOR 3 && (bigintset, bigintset), + -- overlaps or right + OPERATOR 4 &> (bigintset, bigint), + OPERATOR 4 &> (bigintset, bigintset), + -- strictly right + OPERATOR 5 >> (bigintset, bigint), + OPERATOR 5 >> (bigintset, bigintset), + -- contains + OPERATOR 7 @> (bigintset, bigint), + OPERATOR 7 @> (bigintset, bigintset), + -- contained by + OPERATOR 8 <@ (bigintset, bigintset), + -- equals + OPERATOR 18 = (bigintset, bigintset), + -- nearest approach distance + OPERATOR 25 <-> (bigintset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintset, bigintset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, bigintset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 set_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(bigintspan, bigintspan, internal), + FUNCTION 8 span_gist_distance(internal, bigintset, smallint, oid, internal); + +/******************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, floatset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION span_gist_distance(internal, floatset, smallint, oid, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Span_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatset_rtree_ops + DEFAULT FOR TYPE floatset USING gist AS + STORAGE floatspan, + -- strictly left + OPERATOR 1 << (floatset, float), + OPERATOR 1 << (floatset, floatset), + -- overlaps or left + OPERATOR 2 &< (floatset, float), + OPERATOR 2 &< (floatset, floatset), + -- overlaps + OPERATOR 3 && (floatset, floatset), + -- overlaps or right + OPERATOR 4 &> (floatset, float), + OPERATOR 4 &> (floatset, floatset), + -- strictly right + OPERATOR 5 >> (floatset, float), + OPERATOR 5 >> (floatset, floatset), + -- contains + OPERATOR 7 @> (floatset, float), + OPERATOR 7 @> (floatset, floatset), + -- contained by + OPERATOR 8 <@ (floatset, floatset), + -- equals + OPERATOR 18 = (floatset, floatset), + -- nearest approach distance + OPERATOR 25 <-> (floatset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatset, floatset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 span_gist_consistent(internal, floatset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 set_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(floatspan, floatspan, internal), + FUNCTION 8 span_gist_distance(internal, floatset, smallint, oid, internal); + +/*****************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, dateset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE OPERATOR CLASS dateset_rtree_ops + DEFAULT FOR TYPE dateset USING gist AS + STORAGE datespan, + -- overlaps + OPERATOR 3 && (dateset, dateset), + -- contains + OPERATOR 7 @> (dateset, date), + OPERATOR 7 @> (dateset, dateset), + -- contained by + OPERATOR 8 <@ (dateset, dateset), + -- equals + OPERATOR 18 = (dateset, dateset), + -- nearest approach distance + OPERATOR 25 <-> (dateset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (dateset, dateset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (dateset, date), + OPERATOR 28 &<# (dateset, dateset), + -- strictly before + OPERATOR 29 <<# (dateset, date), + OPERATOR 29 <<# (dateset, dateset), + -- strictly after + OPERATOR 30 #>> (dateset, date), + OPERATOR 30 #>> (dateset, dateset), + -- overlaps or after + OPERATOR 31 #&> (dateset, date), + OPERATOR 31 #&> (dateset, dateset), + -- functions + FUNCTION 1 span_gist_consistent(internal, dateset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 set_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(datespan, datespan, internal); + +/*****************************************************************************/ + +CREATE FUNCTION span_gist_consistent(internal, tstzset, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE OPERATOR CLASS tstzset_rtree_ops + DEFAULT FOR TYPE tstzset USING gist AS + STORAGE tstzspan, + -- overlaps + OPERATOR 3 && (tstzset, tstzset), + -- contains + OPERATOR 7 @> (tstzset, timestamptz), + OPERATOR 7 @> (tstzset, tstzset), + -- contained by + OPERATOR 8 <@ (tstzset, tstzset), + -- equals + OPERATOR 18 = (tstzset, tstzset), + -- nearest approach distance + OPERATOR 25 <-> (tstzset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzset, tstzset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzset, timestamptz), + OPERATOR 28 &<# (tstzset, tstzset), + -- strictly before + OPERATOR 29 <<# (tstzset, timestamptz), + OPERATOR 29 <<# (tstzset, tstzset), + -- strictly after + OPERATOR 30 #>> (tstzset, timestamptz), + OPERATOR 30 #>> (tstzset, tstzset), + -- overlaps or after + OPERATOR 31 #&> (tstzset, timestamptz), + OPERATOR 31 #&> (tstzset, tstzset), + -- functions + FUNCTION 1 span_gist_consistent(internal, tstzset, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 set_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(tstzspan, tstzspan, internal); + +/****************************************************************************** + * Quad-tree SP-GiST indexes + ******************************************************************************/ + +CREATE FUNCTION intset_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Intspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION bigintset_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Bigintspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatset_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Floatspan_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION set_spgist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Set_spgist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intset_quadtree_ops + DEFAULT FOR TYPE intset USING spgist AS + -- strictly left + OPERATOR 1 << (intset, integer), + OPERATOR 1 << (intset, intset), + -- overlaps or left + OPERATOR 2 &< (intset, integer), + OPERATOR 2 &< (intset, intset), + -- overlaps + OPERATOR 3 && (intset, intset), + -- overlaps or right + OPERATOR 4 &> (intset, integer), + OPERATOR 4 &> (intset, intset), + -- strictly right + OPERATOR 5 >> (intset, integer), + OPERATOR 5 >> (intset, intset), + -- contains + OPERATOR 7 @> (intset, integer), + OPERATOR 7 @> (intset, intset), + -- contained by + OPERATOR 8 <@ (intset, intset), + -- equals + OPERATOR 18 = (intset, intset), + -- nearest approach distance + OPERATOR 25 <-> (intset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intset, intset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intset_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintset_quadtree_ops + DEFAULT FOR TYPE bigintset USING spgist AS + -- strictly left + OPERATOR 1 << (bigintset, bigint), + OPERATOR 1 << (bigintset, bigintset), + -- overlaps or left + OPERATOR 2 &< (bigintset, bigint), + OPERATOR 2 &< (bigintset, bigintset), + -- overlaps + OPERATOR 3 && (bigintset, bigintset), + -- overlaps or right + OPERATOR 4 &> (bigintset, bigint), + OPERATOR 4 &> (bigintset, bigintset), + -- strictly right + OPERATOR 5 >> (bigintset, bigint), + OPERATOR 5 >> (bigintset, bigintset), + -- contains + OPERATOR 7 @> (bigintset, bigint), + OPERATOR 7 @> (bigintset, bigintset), + -- contained by + OPERATOR 8 <@ (bigintset, bigintset), + -- equals + OPERATOR 18 = (bigintset, bigintset), + -- nearest approach distance + OPERATOR 25 <-> (bigintset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintset, bigintset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intset_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatset_quadtree_ops + DEFAULT FOR TYPE floatset USING spgist AS + -- strictly left + OPERATOR 1 << (floatset, float), + OPERATOR 1 << (floatset, floatset), + -- overlaps or left + OPERATOR 2 &< (floatset, float), + OPERATOR 2 &< (floatset, floatset), + -- overlaps + OPERATOR 3 && (floatset, floatset), + -- overlaps or right + OPERATOR 4 &> (floatset, float), + OPERATOR 4 &> (floatset, floatset), + -- strictly right + OPERATOR 5 >> (floatset, float), + OPERATOR 5 >> (floatset, floatset), + -- contains + OPERATOR 7 @> (floatset, float), + OPERATOR 7 @> (floatset, floatset), + -- contained by + OPERATOR 8 <@ (floatset, floatset), + -- equals + OPERATOR 18 = (floatset, floatset), + -- nearest approach distance + OPERATOR 25 <-> (floatset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatset, floatset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatset_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS dateset_quadtree_ops + DEFAULT FOR TYPE dateset USING spgist AS + -- overlaps + OPERATOR 3 && (dateset, dateset), + -- contains + OPERATOR 7 @> (dateset, date), + OPERATOR 7 @> (dateset, dateset), + -- contained by + OPERATOR 8 <@ (dateset, dateset), + -- equals + OPERATOR 18 = (dateset, dateset), + -- nearest approach distance + OPERATOR 25 <-> (dateset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (dateset, dateset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (dateset, date), + OPERATOR 28 &<# (dateset, dateset), + -- strictly before + OPERATOR 29 <<# (dateset, date), + OPERATOR 29 <<# (dateset, dateset), + -- strictly after + OPERATOR 30 #>> (dateset, date), + OPERATOR 30 #>> (dateset, dateset), + -- overlaps or after + OPERATOR 31 #&> (dateset, date), + OPERATOR 31 #&> (dateset, dateset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzset_quadtree_ops + DEFAULT FOR TYPE tstzset USING spgist AS + -- overlaps + OPERATOR 3 && (tstzset, tstzset), + -- contains + OPERATOR 7 @> (tstzset, timestamptz), + OPERATOR 7 @> (tstzset, tstzset), + -- contained by + OPERATOR 8 <@ (tstzset, tstzset), + -- equals + OPERATOR 18 = (tstzset, tstzset), + -- nearest approach distance + OPERATOR 25 <-> (tstzset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzset, tstzset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzset, timestamptz), + OPERATOR 28 &<# (tstzset, tstzset), + -- strictly before + OPERATOR 29 <<# (tstzset, timestamptz), + OPERATOR 29 <<# (tstzset, tstzset), + -- strictly after + OPERATOR 30 #>> (tstzset, timestamptz), + OPERATOR 30 #>> (tstzset, tstzset), + -- overlaps or after + OPERATOR 31 #&> (tstzset, timestamptz), + OPERATOR 31 #&> (tstzset, tstzset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/****************************************************************************** + * Kd-tree indexes + ******************************************************************************/ + +CREATE OPERATOR CLASS intset_kdtree_ops + FOR TYPE intset USING spgist AS + -- strictly left + OPERATOR 1 << (intset, integer), + OPERATOR 1 << (intset, intset), + -- overlaps or left + OPERATOR 2 &< (intset, integer), + OPERATOR 2 &< (intset, intset), + -- overlaps + OPERATOR 3 && (intset, intset), + -- overlaps or right + OPERATOR 4 &> (intset, integer), + OPERATOR 4 &> (intset, intset), + -- strictly right + OPERATOR 5 >> (intset, integer), + OPERATOR 5 >> (intset, intset), + -- contains + OPERATOR 7 @> (intset, integer), + OPERATOR 7 @> (intset, intset), + -- contained by + OPERATOR 8 <@ (intset, intset), + -- equals + OPERATOR 18 = (intset, intset), + -- nearest approach distance + OPERATOR 25 <-> (intset, integer) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (intset, intset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intset_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintset_kdtree_ops + FOR TYPE bigintset USING spgist AS + -- strictly left + OPERATOR 1 << (bigintset, bigint), + OPERATOR 1 << (bigintset, bigintset), + -- overlaps or left + OPERATOR 2 &< (bigintset, bigint), + OPERATOR 2 &< (bigintset, bigintset), + -- overlaps + OPERATOR 3 && (bigintset, bigintset), + -- overlaps or right + OPERATOR 4 &> (bigintset, bigint), + OPERATOR 4 &> (bigintset, bigintset), + -- strictly right + OPERATOR 5 >> (bigintset, bigint), + OPERATOR 5 >> (bigintset, bigintset), + -- contains + OPERATOR 7 @> (bigintset, bigint), + OPERATOR 7 @> (bigintset, bigintset), + -- contained by + OPERATOR 8 <@ (bigintset, bigintset), + -- equals + OPERATOR 18 = (bigintset, bigintset), + -- nearest approach distance + OPERATOR 25 <-> (bigintset, bigint) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (bigintset, bigintset) FOR ORDER BY pg_catalog.integer_ops, + -- functions + FUNCTION 1 intset_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS floatset_kdtree_ops + FOR TYPE floatset USING spgist AS + -- strictly left + OPERATOR 1 << (floatset, float), + OPERATOR 1 << (floatset, floatset), + -- overlaps or left + OPERATOR 2 &< (floatset, float), + OPERATOR 2 &< (floatset, floatset), + -- overlaps + OPERATOR 3 && (floatset, floatset), + -- overlaps or right + OPERATOR 4 &> (floatset, float), + OPERATOR 4 &> (floatset, floatset), + -- strictly right + OPERATOR 5 >> (floatset, float), + OPERATOR 5 >> (floatset, floatset), + -- contains + OPERATOR 7 @> (floatset, float), + OPERATOR 7 @> (floatset, floatset), + -- contained by + OPERATOR 8 <@ (floatset, floatset), + -- equals + OPERATOR 18 = (floatset, floatset), + -- nearest approach distance + OPERATOR 25 <-> (floatset, float) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (floatset, floatset) FOR ORDER BY pg_catalog.float_ops, + -- functions + FUNCTION 1 floatset_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS dateset_kdtree_ops + FOR TYPE dateset USING spgist AS + -- overlaps + OPERATOR 3 && (dateset, dateset), + -- contains + OPERATOR 7 @> (dateset, date), + OPERATOR 7 @> (dateset, dateset), + -- contained by + OPERATOR 8 <@ (dateset, dateset), + -- equals + OPERATOR 18 = (dateset, dateset), + -- nearest approach distance + OPERATOR 25 <-> (dateset, date) FOR ORDER BY pg_catalog.integer_ops, + OPERATOR 25 <-> (dateset, dateset) FOR ORDER BY pg_catalog.integer_ops, + -- overlaps or before + OPERATOR 28 &<# (dateset, date), + OPERATOR 28 &<# (dateset, dateset), + -- strictly before + OPERATOR 29 <<# (dateset, date), + OPERATOR 29 <<# (dateset, dateset), + -- strictly after + OPERATOR 30 #>> (dateset, date), + OPERATOR 30 #>> (dateset, dateset), + -- overlaps or after + OPERATOR 31 #&> (dateset, date), + OPERATOR 31 #&> (dateset, dateset), + -- functions + FUNCTION 1 datespan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tstzset_kdtree_ops + FOR TYPE tstzset USING spgist AS + -- overlaps + OPERATOR 3 && (tstzset, tstzset), + -- contains + OPERATOR 7 @> (tstzset, timestamptz), + OPERATOR 7 @> (tstzset, tstzset), + -- contained by + OPERATOR 8 <@ (tstzset, tstzset), + -- equals + OPERATOR 18 = (tstzset, tstzset), + -- nearest approach distance + OPERATOR 25 <-> (tstzset, timestamptz) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 <-> (tstzset, tstzset) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tstzset, timestamptz), + OPERATOR 28 &<# (tstzset, tstzset), + -- strictly before + OPERATOR 29 <<# (tstzset, timestamptz), + OPERATOR 29 <<# (tstzset, tstzset), + -- strictly after + OPERATOR 30 #>> (tstzset, timestamptz), + OPERATOR 30 #>> (tstzset, tstzset), + -- overlaps or after + OPERATOR 31 #&> (tstzset, timestamptz), + OPERATOR 31 #&> (tstzset, tstzset), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 set_spgist_compress(internal); + +/****************************************************************************** + * GIN indexes + ******************************************************************************/ + +CREATE FUNCTION set_gin_extract_value(integer, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_value' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_extract_query(integer, internal, int2, internal, internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_query' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_triconsistent(internal, int2, integer, int4, internal, internal, internal) +RETURNS char +AS 'MODULE_PATHNAME', 'Set_gin_triconsistent' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS intset_gin_ops + DEFAULT FOR TYPE intset USING gin AS + STORAGE integer, + -- overlaps + OPERATOR 10 && (intset, intset), + -- contains value + OPERATOR 20 @> (intset, integer), + -- contains set + OPERATOR 21 @> (intset, intset), + -- contained + OPERATOR 30 <@ (intset, intset), + -- same + OPERATOR 40 = (intset, intset), + -- functions + FUNCTION 2 set_gin_extract_value(integer, internal), + FUNCTION 3 set_gin_extract_query(integer, internal, int2, internal, internal, internal, internal), + FUNCTION 6 set_gin_triconsistent(internal, int2, integer, int4, internal, internal, internal); + +/******************************************************************************/ + +CREATE FUNCTION set_gin_extract_value(bigint, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_value' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_extract_query(bigint, internal, int2, internal, internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_query' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_triconsistent(internal, int2, bigint, int4, internal, internal, internal) +RETURNS char +AS 'MODULE_PATHNAME', 'Set_gin_triconsistent' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS bigintset_gin_ops + DEFAULT FOR TYPE bigintset USING gin AS + STORAGE bigint, + -- overlaps + OPERATOR 10 && (bigintset, bigintset), + -- contains value + OPERATOR 20 @> (bigintset, bigint), + -- contains set + OPERATOR 21 @> (bigintset, bigintset), + -- contained + OPERATOR 30 <@ (bigintset, bigintset), + -- equal + OPERATOR 40 = (bigintset, bigintset), + -- functions + FUNCTION 2 set_gin_extract_value(bigint, internal), + FUNCTION 3 set_gin_extract_query(bigint, internal, int2, internal, internal, internal, internal), + FUNCTION 6 set_gin_triconsistent(internal, int2, bigint, int4, internal, internal, internal); + +/******************************************************************************/ + +CREATE FUNCTION set_gin_extract_value(date, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_value' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_extract_query(date, internal, int2, internal, internal, internal, internal) +RETURNS internal +AS 'MODULE_PATHNAME', 'Set_gin_extract_query' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION set_gin_triconsistent(internal, int2, date, int4, internal, internal, internal) +RETURNS char +AS 'MODULE_PATHNAME', 'Set_gin_triconsistent' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS dateset_gin_ops + DEFAULT FOR TYPE dateset USING gin AS + STORAGE date, + -- overlaps + OPERATOR 10 && (dateset, dateset), + -- contains value + OPERATOR 20 @> (dateset, date), + -- contains set + OPERATOR 21 @> (dateset, dateset), + -- contained + OPERATOR 30 <@ (dateset, dateset), + -- same + OPERATOR 40 = (dateset, dateset), + -- functions + FUNCTION 2 set_gin_extract_value(date, internal), + FUNCTION 3 set_gin_extract_query(date, internal, int2, internal, internal, internal, internal), + FUNCTION 6 set_gin_triconsistent(internal, int2, date, int4, internal, internal, internal); + +/******************************************************************************/ + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/015_span_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/015_span_aggfuncs.in.sql new file mode 100644 index 0000000..985fbcb --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/015_span_aggfuncs.in.sql @@ -0,0 +1,438 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Aggregate functions for types whose bounding box is a span + */ + +/*****************************************************************************/ +-- span + span + +-- The function is not strict +CREATE FUNCTION span_extent_transfn(intspan, intspan) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_combinefn(intspan, intspan) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION span_extent_transfn(bigintspan, bigintspan) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_combinefn(bigintspan, bigintspan) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION span_extent_transfn(floatspan, floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_combinefn(floatspan, floatspan) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(datespan, datespan) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_combinefn(datespan, datespan) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(tstzspan, tstzspan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_combinefn(tstzspan, tstzspan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(intspan) ( + SFUNC = span_extent_transfn, + STYPE = intspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(bigintspan) ( + SFUNC = span_extent_transfn, + STYPE = bigintspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(floatspan) ( + SFUNC = span_extent_transfn, + STYPE = floatspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(datespan) ( + SFUNC = span_extent_transfn, + STYPE = datespan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tstzspan) ( + SFUNC = span_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ +-- span + base + +-- The function is not strict +CREATE FUNCTION span_extent_transfn(intspan, integer) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanbase_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(bigintspan, bigint) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanbase_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(floatspan, float) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanbase_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(datespan, date) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanbase_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION span_extent_transfn(tstzspan, timestamptz) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanbase_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(integer) ( + SFUNC = span_extent_transfn, + STYPE = intspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(bigint) ( + SFUNC = span_extent_transfn, + STYPE = bigintspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(float) ( + SFUNC = span_extent_transfn, + STYPE = floatspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(date) ( + SFUNC = span_extent_transfn, + STYPE = datespan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(timestamptz) ( + SFUNC = span_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ +-- span + + +-- The function is not strict +CREATE FUNCTION set_extent_transfn(intspan, intset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Set_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_extent_transfn(bigintspan, bigintset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Set_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_extent_transfn(floatspan, floatset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Set_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_extent_transfn(datespan, dateset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Set_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION set_extent_transfn(tstzspan, tstzset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Set_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(intset) ( + SFUNC = set_extent_transfn, + STYPE = intspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(bigintset) ( + SFUNC = set_extent_transfn, + STYPE = bigintspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(floatset) ( + SFUNC = set_extent_transfn, + STYPE = floatspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(dateset) ( + SFUNC = set_extent_transfn, + STYPE = datespan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tstzset) ( + SFUNC = set_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); + +-- The function is not strict +CREATE FUNCTION spanset_extent_transfn(intspan, intspanset) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Spanset_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_extent_transfn(bigintspan, bigintspanset) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Spanset_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_extent_transfn(floatspan, floatspanset) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Spanset_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_extent_transfn(datespan, datespanset) + RETURNS datespan + AS 'MODULE_PATHNAME', 'Spanset_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_extent_transfn(tstzspan, tstzspanset) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Spanset_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(intspanset) ( + SFUNC = spanset_extent_transfn, + STYPE = intspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(bigintspanset) ( + SFUNC = spanset_extent_transfn, + STYPE = bigintspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(floatspanset) ( + SFUNC = spanset_extent_transfn, + STYPE = floatspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(datespanset) ( + SFUNC = spanset_extent_transfn, + STYPE = datespan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tstzspanset) ( + SFUNC = spanset_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = span_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION intspan_union_finalfn(internal) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Span_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION bigintspan_union_finalfn(internal) + RETURNS bigintspanset + AS 'MODULE_PATHNAME', 'Span_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION floatspan_union_finalfn(internal) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Span_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION datespan_union_finalfn(internal) + RETURNS datespanset + AS 'MODULE_PATHNAME', 'Span_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tstzspan_union_finalfn(internal) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Span_union_finalfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE spanUnion(intspan) ( + SFUNC = array_agg_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = intspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(bigintspan) ( + SFUNC = array_agg_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = bigintspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(floatspan) ( + SFUNC = array_agg_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = floatspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(datespan) ( + SFUNC = array_agg_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = datespan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(tstzspan) ( + SFUNC = array_agg_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = tstzspan_union_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION spanset_union_transfn(internal, intspanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_union_transfn(internal, bigintspanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_union_transfn(internal, floatspanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_union_transfn(internal, datespanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION spanset_union_transfn(internal, tstzspanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Spanset_union_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE spanUnion(intspanset) ( + SFUNC = spanset_union_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = intspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(bigintspanset) ( + SFUNC = spanset_union_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = bigintspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(floatspanset) ( + SFUNC = spanset_union_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = floatspan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(datespanset) ( + SFUNC = spanset_union_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = datespan_union_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE spanUnion(tstzspanset) ( + SFUNC = spanset_union_transfn, + STYPE = internal, +#if POSTGRESQL_VERSION_NUMBER >= 160000 + COMBINEFUNC = array_agg_combine, + SERIALFUNC = array_agg_serialize, + DESERIALFUNC = array_agg_deserialize, +#endif //POSTGRESQL_VERSION_NUMBER >= 160000 + FINALFUNC = tstzspan_union_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/019_geo_constructors.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/019_geo_constructors.in.sql new file mode 100644 index 0000000..65849de --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/019_geo_constructors.in.sql @@ -0,0 +1,70 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief SQL constructors for PostgreSQL geometric types + */ + +CREATE FUNCTION point(float, float) + RETURNS point + AS 'MODULE_PATHNAME', 'point_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION line(float, float, float) + RETURNS line + AS 'MODULE_PATHNAME', 'line_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lseg(point, point) + RETURNS lseg + AS 'MODULE_PATHNAME', 'lseg_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION box(point, point) + RETURNS box + AS 'MODULE_PATHNAME', 'box_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION circle(point, float) + RETURNS circle + AS 'MODULE_PATHNAME', 'circle_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION path(point[]) + RETURNS path + AS 'MODULE_PATHNAME', 'path_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION polygon(point[]) + RETURNS polygon + AS 'MODULE_PATHNAME', 'poly_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/021_tbox.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/021_tbox.in.sql new file mode 100644 index 0000000..083a979 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/021_tbox.in.sql @@ -0,0 +1,625 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Functions for temporal bounding boxes + */ + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE TYPE tbox; + +CREATE FUNCTION tbox_in(cstring) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_out(tbox) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Tbox_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_recv(internal) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_send(tbox) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tbox_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tbox ( + internallength = 56, + input = tbox_in, + output = tbox_out, + receive = tbox_recv, + send = tbox_send, + storage = plain, + alignment = double +); + +-- Input/output in WKB and HexWKB representation + +CREATE FUNCTION tboxFromBinary(bytea) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tboxFromHexWKB(text) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(tbox, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Tbox_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asBinary(tbox, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Tbox_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(tbox, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Tbox_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Constructor functions + ******************************************************************************/ + +CREATE FUNCTION tbox(integer, timestamptz) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_timestamptz_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(intspan, timestamptz) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Numspan_timestamptz_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(float, timestamptz) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_timestamptz_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(floatspan, timestamptz) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Numspan_timestamptz_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(integer, tstzspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_tstzspan_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(intspan, tstzspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Numspan_tstzspan_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(float, tstzspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_tstzspan_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(floatspan, tstzspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Numspan_tstzspan_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Conversion functions + *****************************************************************************/ + +CREATE FUNCTION tbox(integer) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(float) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Number_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(numeric) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Numeric_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(timestamptz) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Timestamptz_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbox(intset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Set_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(floatset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Set_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(tstzset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Set_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbox(intspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Span_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(floatspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Span_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(tstzspan) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Span_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbox(intspanset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Spanset_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(floatspanset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Spanset_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(tstzspanset) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Spanset_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (integer AS tbox) WITH FUNCTION tbox(integer); +CREATE CAST (float AS tbox) WITH FUNCTION tbox(float); +CREATE CAST (numeric AS tbox) WITH FUNCTION tbox(numeric); +CREATE CAST (timestamptz AS tbox) WITH FUNCTION tbox(timestamptz); + +CREATE CAST (intset AS tbox) WITH FUNCTION tbox(intset); +CREATE CAST (floatset AS tbox) WITH FUNCTION tbox(floatset); +CREATE CAST (tstzset AS tbox) WITH FUNCTION tbox(tstzset); + +CREATE CAST (intspan AS tbox) WITH FUNCTION tbox(intspan); +CREATE CAST (floatspan AS tbox) WITH FUNCTION tbox(floatspan); +CREATE CAST (tstzspan AS tbox) WITH FUNCTION tbox(tstzspan); + +CREATE CAST (intspanset AS tbox) WITH FUNCTION tbox(intspanset); +CREATE CAST (floatspanset AS tbox) WITH FUNCTION tbox(floatspanset); +CREATE CAST (tstzspanset AS tbox) WITH FUNCTION tbox(tstzspanset); + +CREATE FUNCTION intspan(tbox) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Tbox_to_intspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION floatspan(tbox) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Tbox_to_floatspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tbox) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Tbox_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tbox AS intspan) WITH FUNCTION intspan(tbox); +CREATE CAST (tbox AS floatspan) WITH FUNCTION floatspan(tbox); +CREATE CAST (tbox AS tstzspan) WITH FUNCTION timeSpan(tbox); + +/***************************************************************************** + * Accessor functions + *****************************************************************************/ + +CREATE FUNCTION hasX(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_hasx' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION hasT(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_hast' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION Xmin(tbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Tbox_xmin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION XminInc(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_xmin_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Xmax(tbox) + RETURNS float + AS 'MODULE_PATHNAME', 'Tbox_xmax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION XmaxInc(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_xmax_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Tmin(tbox) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tbox_tmin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION TminInc(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_tmin_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION Tmax(tbox) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tbox_tmax' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION TmaxInc(tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_tmax_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transformation functions + *****************************************************************************/ + +CREATE FUNCTION shiftValue(tbox, integer) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftValue(tbox, float) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(tbox, interval) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleValue(tbox, integer) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleValue(tbox, float) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(tbox, interval) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleValue(tbox, integer, integer) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleValue(tbox, float, float) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(tbox, interval, interval) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION expandValue(tbox, integer) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_expand_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expandValue(tbox, float) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_expand_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION expandTime(tbox, interval) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_expand_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tbox, integer DEFAULT 0) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Selectivity functions + *****************************************************************************/ + +CREATE FUNCTION tnumber_sel(internal, oid, internal, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_sel' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION tnumber_joinsel(internal, oid, internal, smallint, internal) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_joinsel' + LANGUAGE C IMMUTABLE STRICT; + +/***************************************************************************** + * Topological operators + *****************************************************************************/ + +CREATE FUNCTION tbox_contains(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_contained(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_overlaps(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_same(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_adjacent(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = tbox_contains, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = tbox_contained, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = tbox_overlaps, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = tbox_same, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = tbox_adjacent, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * Position operators + *****************************************************************************/ + +CREATE FUNCTION tbox_left(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_overleft(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_right(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_overright(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_before(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_overbefore(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_after(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_overafter(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + PROCEDURE = tbox_left, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + PROCEDURE = tbox_overleft, + LEFTARG = tbox, RIGHTARG = tbox, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tbox, RIGHTARG = tbox, + PROCEDURE = tbox_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + PROCEDURE = tbox_overright, + LEFTARG = tbox, RIGHTARG = tbox, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + PROCEDURE = tbox_before, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + PROCEDURE = tbox_overbefore, + LEFTARG = tbox, RIGHTARG = tbox, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + PROCEDURE = tbox_after, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + PROCEDURE = tbox_overafter, + LEFTARG = tbox, RIGHTARG = tbox, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * Set operators + *****************************************************************************/ + +CREATE FUNCTION tbox_union(tbox, tbox) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Union_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_intersection(tbox, tbox) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Intersection_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = tbox_union, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = + +); +CREATE OPERATOR * ( + PROCEDURE = tbox_intersection, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = * +); + +/***************************************************************************** + * Extent aggregation + *****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tbox_extent_transfn(tbox, tbox) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tbox_extent_combinefn(tbox, tbox) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(tbox) ( + SFUNC = tbox_extent_transfn, + STYPE = tbox, + COMBINEFUNC = tbox_extent_combinefn, + PARALLEL = safe +); + +/***************************************************************************** + * Comparison + *****************************************************************************/ + +CREATE FUNCTION tbox_eq(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_ne(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_lt(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_le(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_ge(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gt(tbox, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tbox_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_cmp(tbox, tbox) + RETURNS int4 + AS 'MODULE_PATHNAME', 'Tbox_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR = ( + LEFTARG = tbox, RIGHTARG = tbox, + PROCEDURE = tbox_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tbox, RIGHTARG = tbox, + PROCEDURE = tbox_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR < ( + PROCEDURE = tbox_lt, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR <= ( + PROCEDURE = tbox_le, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR >= ( + PROCEDURE = tbox_ge, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = areasel, JOIN = areajoinsel +); +CREATE OPERATOR > ( + PROCEDURE = tbox_gt, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = areasel, JOIN = areajoinsel +); + +CREATE OPERATOR CLASS tbox_btree_ops + DEFAULT FOR TYPE tbox USING btree AS + OPERATOR 1 < , + OPERATOR 2 <= , + OPERATOR 3 = , + OPERATOR 4 >= , + OPERATOR 5 > , + FUNCTION 1 tbox_cmp(tbox, tbox); + +/*****************************************************************************/ + +CREATE FUNCTION tbox_hash(tbox) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tbox_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbox_hash_extended(tbox, bigint) + RETURNS bigint + AS 'MODULE_PATHNAME', 'Tbox_hash_extended' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tbox_hash_ops + DEFAULT FOR TYPE tbox USING hash AS + OPERATOR 1 = , + FUNCTION 1 tbox_hash(tbox), + FUNCTION 2 tbox_hash_extended(tbox, bigint); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/022_temporal.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/022_temporal.in.sql new file mode 100644 index 0000000..a808501 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/022_temporal.in.sql @@ -0,0 +1,2188 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Basic functions for temporal types + */ + +CREATE TYPE tbool; +CREATE TYPE tint; +CREATE TYPE tfloat; +CREATE TYPE ttext; + +/***************************************************************************** + * Utility functions + *****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION mobilitydb_version() + RETURNS text + AS 'MODULE_PATHNAME', 'Mobilitydb_version' + LANGUAGE C IMMUTABLE; + +CREATE FUNCTION mobilitydb_full_version() + RETURNS text + AS 'MODULE_PATHNAME', 'Mobilitydb_full_version' + LANGUAGE C IMMUTABLE; + +/****************************************************************************** + * Input/Output + ******************************************************************************/ + +CREATE FUNCTION tbool_in(cstring, oid, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint_in(cstring, oid, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat_in(cstring, oid, integer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext_in(cstring, oid, integer) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION temporal_out(tbool) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tint) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(tfloat) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_out(ttext) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbool_recv(internal, oid, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint_recv(internal, oid, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat_recv(internal, oid, integer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext_recv(internal, oid, integer) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_recv' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION temporal_send(tbool) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tint) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(tfloat) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_send(ttext) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_send' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION temporal_typmod_in(cstring[]) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_typmod_in' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_typmod_out(integer) + RETURNS cstring + AS 'MODULE_PATHNAME', 'Temporal_typmod_out' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION temporal_analyze(internal) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_analyze' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE TYPE tbool ( + internallength = variable, + input = tbool_in, + output = temporal_out, + send = temporal_send, + receive = tbool_recv, + typmod_in = temporal_typmod_in, + typmod_out = temporal_typmod_out, + storage = extended, + alignment = double, + analyze = temporal_analyze +); +CREATE TYPE tint ( + internallength = variable, + input = tint_in, + output = temporal_out, + send = temporal_send, + receive = tint_recv, + typmod_in = temporal_typmod_in, + typmod_out = temporal_typmod_out, + storage = extended, + alignment = double, + analyze = temporal_analyze +); +CREATE TYPE tfloat ( + internallength = variable, + input = tfloat_in, + output = temporal_out, + send = temporal_send, + receive = tfloat_recv, + typmod_in = temporal_typmod_in, + typmod_out = temporal_typmod_out, + storage = extended, + alignment = double, + analyze = temporal_analyze +); +CREATE TYPE ttext ( + internallength = variable, + input = ttext_in, + output = temporal_out, + send = temporal_send, + receive = ttext_recv, + typmod_in = temporal_typmod_in, + typmod_out = temporal_typmod_out, + storage = extended, + alignment = double, + analyze = temporal_analyze +); + +-- Special cast for enforcing the typmod restrictions +CREATE FUNCTION tbool(tbool, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(tfloat, integer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext(ttext, integer) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_enforce_typmod' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tbool AS tbool) WITH FUNCTION tbool(tbool, integer) AS IMPLICIT; +CREATE CAST (tint AS tint) WITH FUNCTION tint(tint, integer) AS IMPLICIT; +CREATE CAST (tfloat AS tfloat) WITH FUNCTION tfloat(tfloat, integer) AS IMPLICIT; +CREATE CAST (ttext AS ttext) WITH FUNCTION ttext(ttext, integer) AS IMPLICIT; + +/****************************************************************************** + * Constructor functions + ******************************************************************************/ + +CREATE FUNCTION tbool(boolean, timestamptz) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(integer, timestamptz) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(float, timestamptz) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext(text, timestamptz) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tinstant_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbool(boolean, tstzset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(integer, tstzset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(float, tstzset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext(text, tstzset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbool(boolean, tstzspan) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(integer, tstzspan) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(float, tstzspan, text DEFAULT 'linear') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext(text, tstzspan) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequence_from_base_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tbool(boolean, tstzspanset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(integer, tstzspanset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat(float, tstzspanset, text DEFAULT 'linear') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext(text, tstzspanset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequenceset_from_base_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tboolSeq(tbool[], text DEFAULT 'step', + lowerInc boolean DEFAULT true, upperInc boolean DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintSeq(tint[], text DEFAULT 'step', + lowerInc boolean DEFAULT true, upperInc boolean DEFAULT true) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatSeq(tfloat[], text DEFAULT 'linear', + lowerInc boolean DEFAULT true, upperInc boolean DEFAULT true) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextSeq(ttext[], text DEFAULT 'step', + lowerInc boolean DEFAULT true, upperInc boolean DEFAULT true) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequence_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tboolSeqSet(tbool[]) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintSeqSet(tint[]) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatSeqSet(tfloat[]) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextSeqSet(ttext[]) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tboolSeqSetGaps(tbool[], maxt interval DEFAULT NULL) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tintSeqSetGaps(tint[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloatSeqSetGaps(tfloat[], maxt interval DEFAULT NULL, + maxdist float DEFAULT NULL, text DEFAULT 'linear') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttextSeqSetGaps(ttext[], maxt interval DEFAULT NULL) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Tsequenceset_constructor_gaps' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +/****************************************************************************** + * Conversion functions + ******************************************************************************/ + +CREATE FUNCTION timeSpan(tbool) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tint) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(tfloat) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timeSpan(ttext) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_to_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueSpan(tint) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Tnumber_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueSpan(tfloat) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Tnumber_to_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tbool AS tstzspan) WITH FUNCTION timeSpan(tbool); +CREATE CAST (tint AS tstzspan) WITH FUNCTION timeSpan(tint); +CREATE CAST (tfloat AS tstzspan) WITH FUNCTION timeSpan(tfloat); +CREATE CAST (ttext AS tstzspan) WITH FUNCTION timeSpan(ttext); + +CREATE CAST (tint AS intspan) WITH FUNCTION valueSpan(tint); +CREATE CAST (tfloat AS floatspan) WITH FUNCTION valueSpan(tfloat); + +CREATE FUNCTION tint(tbool) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tbool_to_tint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE CAST (tbool AS tint) WITH FUNCTION tint(tbool); + +CREATE FUNCTION tfloat(tint) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tint_to_tfloat' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint(tfloat) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tfloat_to_tint' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tint AS tfloat) WITH FUNCTION tfloat(tint); +CREATE CAST (tfloat AS tint) WITH FUNCTION tint(tfloat); + +CREATE FUNCTION tbox(tint) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tnumber_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox(tfloat) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tnumber_to_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE CAST (tint AS tbox) WITH FUNCTION tbox(tint); +CREATE CAST (tfloat AS tbox) WITH FUNCTION tbox(tfloat); + +/****************************************************************************** + * Accessor functions + ******************************************************************************/ + +CREATE FUNCTION tempSubtype(tbool) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tempSubtype(tint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tempSubtype(tfloat) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tempSubtype(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_subtype' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION interp(tbool) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION interp(tint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION interp(tfloat) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION interp(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION memSize(tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION memSize(ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_mem_size' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- values is a reserved word in SQL +CREATE FUNCTION getValue(tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValue(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValue(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Tinstant_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- values is a reserved word in SQL +CREATE FUNCTION getValues(tbool) + RETURNS boolean[] + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(tint) + RETURNS intspanset + AS 'MODULE_PATHNAME', 'Tnumber_valuespans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(tfloat) + RETURNS floatspanset + AS 'MODULE_PATHNAME', 'Tnumber_valuespans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getValues(ttext) + RETURNS textset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueSet(tint) + RETURNS intset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueSet(tfloat) + RETURNS floatset + AS 'MODULE_PATHNAME', 'Temporal_valueset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startValue(tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startValue(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_start_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endValue(tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endValue(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_end_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minValue(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_min_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_min_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minValue(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_min_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION maxValue(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_max_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION maxValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_max_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION maxValue(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_max_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION avgValue(tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_avg_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION avgValue(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_avg_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueN(tbool, integer) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(tint, integer) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(tfloat, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueN(ttext, integer) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_value_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minInstant(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_min_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minInstant(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_min_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minInstant(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_min_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION maxInstant(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_max_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION maxInstant(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_max_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION maxInstant(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_max_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- timestamp is a reserved word in SQL +CREATE FUNCTION getTimestamp(tbool) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTimestamp(tint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTimestamp(tfloat) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTimestamp(ttext) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Tinstant_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- time is a reserved word in SQL +CREATE FUNCTION getTime(tbool) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTime(tint) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTime(tfloat) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getTime(ttext) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION duration(tbool, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tint, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(tfloat, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION duration(ttext, boundspan boolean DEFAULT FALSE) + RETURNS interval + AS 'MODULE_PATHNAME', 'Temporal_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numSequences(tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSequences(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSequences(tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numSequences(ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startSequence(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSequence(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSequence(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startSequence(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_start_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endSequence(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSequence(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSequence(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endSequence(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_end_sequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequenceN(tbool, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequenceN(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequenceN(tfloat, integer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequenceN(ttext, integer) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_sequence_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION sequences(tbool) + RETURNS tbool[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequences(tint) + RETURNS tint[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequences(tfloat) + RETURNS tfloat[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION sequences(ttext) + RETURNS ttext[] + AS 'MODULE_PATHNAME', 'Temporal_sequences' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segments(tbool) + RETURNS tbool[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segments(tint) + RETURNS tint[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segments(tfloat) + RETURNS tfloat[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segments(ttext) + RETURNS ttext[] + AS 'MODULE_PATHNAME', 'Temporal_segments' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lowerInc(tbool) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(tfloat) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION lowerInc(ttext) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_lower_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION upperInc(tbool) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tint) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(tfloat) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION upperInc(ttext) + RETURNS bool + AS 'MODULE_PATHNAME', 'Temporal_upper_inc' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numInstants(tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numInstants(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numInstants(tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numInstants(ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startInstant(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startInstant(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startInstant(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startInstant(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_start_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endInstant(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endInstant(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endInstant(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endInstant(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_end_instant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instantN(tbool, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instantN(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instantN(tfloat, integer) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instantN(ttext, integer) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_instant_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION instants(tbool) + RETURNS tbool[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instants(tint) + RETURNS tint[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instants(tfloat) + RETURNS tfloat[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION instants(ttext) + RETURNS ttext[] + AS 'MODULE_PATHNAME', 'Temporal_instants' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION numTimestamps(tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numTimestamps(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numTimestamps(tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION numTimestamps(ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_num_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION startTimestamp(tbool) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startTimestamp(tint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startTimestamp(tfloat) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION startTimestamp(ttext) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_start_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION endTimestamp(tbool) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endTimestamp(tint) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endTimestamp(tfloat) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION endTimestamp(ttext) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_end_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestampN(tbool, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestampN(tint, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestampN(tfloat, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestampN(ttext, integer) + RETURNS timestamptz + AS 'MODULE_PATHNAME', 'Temporal_timestamptz_n' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timestamps(tbool) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestamps(tint) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestamps(tfloat) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION timestamps(ttext) + RETURNS timestamptz[] + AS 'MODULE_PATHNAME', 'Temporal_timestamps' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Transform a temporal value to a set of records + *****************************************************************************/ + +CREATE TYPE int_tstzspanset AS ( + value integer, + time tstzspanset +); +CREATE TYPE float_tstzspanset AS ( + value float, + time tstzspanset +); +CREATE TYPE text_tstzspanset AS ( + value text, + time tstzspanset +); + +CREATE FUNCTION unnest(tint) + RETURNS SETOF int_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(tfloat) + RETURNS SETOF float_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION unnest(ttext) + RETURNS SETOF text_tstzspanset + AS 'MODULE_PATHNAME', 'Temporal_unnest' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/****************************************************************************** + * Transformation functions + ******************************************************************************/ + +CREATE FUNCTION tboolInst(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintInst(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatInst(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextInst(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_to_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tboolSeq(tbool, text DEFAULT NULL) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tintSeq(tint, text DEFAULT NULL) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloatSeq(tfloat, text DEFAULT NULL) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttextSeq(ttext, text DEFAULT NULL) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_to_tsequence' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION tboolSeqSet(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tintSeqSet(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloatSeqSet(tfloat, text DEFAULT NULL) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttextSeqSet(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_to_tsequenceset' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION setInterp(tbool, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setInterp(tint, text) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setInterp(tfloat, text) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION setInterp(ttext, text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_set_interp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION shiftValue(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_shift_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftValue(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_shift_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleValue(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleValue(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleValue(tint, integer, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_shift_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleValue(tfloat, float, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_shift_scale_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION shiftTime(tbool, interval) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(tint, interval) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(tfloat, interval) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftTime(ttext, interval) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_shift_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION scaleTime(tbool, interval) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(tint, interval) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(tfloat, interval) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION scaleTime(ttext, interval) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION shiftScaleTime(tbool, interval, interval) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(tint, interval, interval) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(tfloat, interval, interval) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION shiftScaleTime(ttext, interval, interval) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_shift_scale_time' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tprecision(tint, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tprecision(tfloat, duration interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_tprecision' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tsample(tbool, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tsample(tint, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tsample(tfloat, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tsample(ttext, duration interval, + origin timestamptz DEFAULT '2000-01-03', interp text DEFAULT 'discrete') + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_tsample' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION appendInstant(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendInstant(tbool, tbool, interp text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tint, tint, interp text) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(tfloat, tfloat, interp text) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendInstant(ttext, ttext, interp text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_append_tinstant' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION appendSequence(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION appendSequence(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_append_tsequence' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- The function is not strict +CREATE FUNCTION merge(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION merge(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION merge(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION merge(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_merge' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION merge(tbool[]) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tint[]) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(tfloat[]) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION merge(ttext[]) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_merge_array' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Restriction functions + *****************************************************************************/ + +CREATE FUNCTION atValues(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(ttext, text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(ttext, text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tint, intset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tfloat, floatset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(ttext, textset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tint, intset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tfloat, floatset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(ttext, textset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_values' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tint, intspan) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_at_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tfloat, floatspan) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_at_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tint, intspan) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_minus_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tfloat, floatspan) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_minus_span' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atValues(tint, intspanset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_at_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atValues(tfloat, floatspanset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_at_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusValues(tint, intspanset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_minus_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusValues(tfloat, floatspanset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_minus_spanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atMin(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atMin(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atMin(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusMin(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusMin(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusMin(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_min' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atMax(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atMax(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atMax(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusMax(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusMax(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusMax(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_max' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTbox(tint, tbox) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_at_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTbox(tfloat, tbox) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_at_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTbox(tint, tbox) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_minus_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTbox(tfloat, tbox) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_minus_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tbool, timestamptz) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tint, timestamptz) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tfloat, timestamptz) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(ttext, timestamptz) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tbool, timestamptz) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tint, timestamptz) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tfloat, timestamptz) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(ttext, timestamptz) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueAtTimestamp(tbool, timestamptz) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueAtTimestamp(tint, timestamptz) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueAtTimestamp(tfloat, timestamptz) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION valueAtTimestamp(ttext, timestamptz) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_value_at_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tbool, tstzset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tint, tstzset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tfloat, tstzset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(ttext, tstzset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tbool, tstzset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tint, tstzset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tfloat, tstzset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(ttext, tstzset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tbool, tstzspan) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tint, tstzspan) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tfloat, tstzspan) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(ttext, tstzspan) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tbool, tstzspan) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tint, tstzspan) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tfloat, tstzspan) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(ttext, tstzspan) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION atTime(tbool, tstzspanset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tint, tstzspanset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(tfloat, tstzspanset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION atTime(ttext, tstzspanset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_at_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minusTime(tbool, tstzspanset) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tint, tstzspanset) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(tfloat, tstzspanset) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION minusTime(ttext, tstzspanset) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_minus_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION beforeTimestamp(tbool, timestamptz, strict bool DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION beforeTimestamp(tint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION beforeTimestamp(tfloat, timestamptz, strict bool DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION beforeTimestamp(ttext, timestamptz, strict bool DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_before_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION afterTimestamp(tbool, timestamptz, strict bool DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION afterTimestamp(tint, timestamptz, strict bool DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION afterTimestamp(tfloat, timestamptz, strict bool DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION afterTimestamp(ttext, timestamptz, strict bool DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_after_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Modification Functions + *****************************************************************************/ + +CREATE FUNCTION insert(tbool, tbool, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_insert' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION insert(tint, tint, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_insert' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION insert(tfloat, tfloat, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_insert' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION insert(ttext, ttext, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_insert' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION update(tbool, tbool, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION update(tint, tint, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION update(tfloat, tfloat, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION update(ttext, ttext, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_update' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tbool, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tint, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tfloat, timestamptz, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(ttext, timestamptz, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_delete_timestamptz' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tbool, tstzset, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tint, tstzset, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tfloat, tstzset, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(ttext, tstzset, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tbool, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tint, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tfloat, tstzspan, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(ttext, tstzspan, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deleteTime(tbool, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tint, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(tfloat, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deleteTime(ttext, tstzspanset, connect boolean DEFAULT TRUE) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_delete_tstzspanset' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Segment Duration Functions + *****************************************************************************/ + +CREATE FUNCTION segmentMinDuration(tbool, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_min_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMinDuration(tint, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_min_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMinDuration(tfloat, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_min_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMinDuration(ttext, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_min_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION segmentMaxDuration(tbool, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_max_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMaxDuration(tint, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_max_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMaxDuration(tfloat, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_max_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION segmentMaxDuration(ttext, interval, bool DEFAULT true) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_segm_max_duration' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Stops Functions + *****************************************************************************/ + +CREATE FUNCTION stops(tfloat, maxdist float DEFAULT 0.0, + minduration interval DEFAULT '0 minutes') + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_stops' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION stops(tfloat, minduration interval) + RETURNS tfloat + AS 'SELECT @extschema@.stops($1, 0.0, $2)' + LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Local Aggregate Functions + *****************************************************************************/ + +CREATE FUNCTION integral(tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_integral' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION integral(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_integral' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION twAvg(tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_twavg' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION twAvg(tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Tnumber_twavg' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Selectivity functions for operators + *****************************************************************************/ + +CREATE FUNCTION temporal_sel(internal, oid, internal, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_sel' + LANGUAGE C IMMUTABLE STRICT; + +CREATE FUNCTION temporal_joinsel(internal, oid, internal, smallint, internal) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_joinsel' + LANGUAGE C IMMUTABLE STRICT; + +/****************************************************************************** + * Comparison functions and B-tree indexing + ******************************************************************************/ + +CREATE FUNCTION temporal_lt(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tbool, tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = temporal_sel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = temporal_sel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = temporal_sel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = temporal_sel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS tbool_btree_ops + DEFAULT FOR TYPE tbool USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tbool, tbool); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_lt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tint, tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +CREATE OPERATOR CLASS tint_btree_ops + DEFAULT FOR TYPE tint USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tint, tint); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_lt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(tfloat, tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR = ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR > ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +CREATE OPERATOR CLASS tfloat_btree_ops + DEFAULT FOR TYPE tfloat USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(tfloat, tfloat); + +/******************************************************************************/ + +CREATE FUNCTION temporal_lt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_lt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_le(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_le' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_eq(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_eq' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ne(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ne' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_ge(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_ge' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_gt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Temporal_gt' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_cmp(ttext, ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_cmp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR < ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_lt, + COMMUTATOR = >, NEGATOR = >=, + RESTRICT = temporal_sel, JOIN = scalarltjoinsel +); +CREATE OPERATOR <= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_le, + COMMUTATOR = >=, NEGATOR = >, + RESTRICT = temporal_sel, JOIN = scalarltjoinsel +); +CREATE OPERATOR = ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_eq, + COMMUTATOR = =, NEGATOR = <>, + RESTRICT = eqsel, JOIN = eqjoinsel +); +CREATE OPERATOR <> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_ne, + COMMUTATOR = <>, NEGATOR = =, + RESTRICT = neqsel, JOIN = neqjoinsel +); +CREATE OPERATOR >= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_ge, + COMMUTATOR = <=, NEGATOR = <, + RESTRICT = temporal_sel, JOIN = scalargtjoinsel +); +CREATE OPERATOR > ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_gt, + COMMUTATOR = <, NEGATOR = <=, + RESTRICT = temporal_sel, JOIN = scalargtjoinsel +); + +CREATE OPERATOR CLASS ttext_btree_ops + DEFAULT FOR TYPE ttext USING btree AS + OPERATOR 1 <, + OPERATOR 2 <=, + OPERATOR 3 =, + OPERATOR 4 >=, + OPERATOR 5 >, + FUNCTION 1 temporal_cmp(ttext, ttext); + +/******************************************************************************/ + +CREATE FUNCTION temporal_hash(tbool) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_hash(tint) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_hash(tfloat) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_hash(ttext) + RETURNS integer + AS 'MODULE_PATHNAME', 'Temporal_hash' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR CLASS tbool_hash_ops + DEFAULT FOR TYPE tbool USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tbool); +CREATE OPERATOR CLASS tint_hash_ops + DEFAULT FOR TYPE tint USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tint); +CREATE OPERATOR CLASS tfloat_hash_ops + DEFAULT FOR TYPE tfloat USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(tfloat); +CREATE OPERATOR CLASS ttext_hash_ops + DEFAULT FOR TYPE ttext USING hash AS + OPERATOR 1 = , + FUNCTION 1 temporal_hash(ttext); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/023_temporal_inout.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/023_temporal_inout.in.sql new file mode 100644 index 0000000..45b5ba1 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/023_temporal_inout.in.sql @@ -0,0 +1,190 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Input/output of temporal types in WKT, MF-JSON, and WKB + * representation + */ + +/***************************************************************************** + * Input + *****************************************************************************/ + +CREATE FUNCTION tboolFromMFJSON(text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintFromMFJSON(text) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatFromMFJSON(text) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextFromMFJSON(text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_from_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION tboolFromBinary(bytea) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintFromBinary(bytea) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatFromBinary(bytea) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextFromBinary(bytea) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_from_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tboolFromHexWKB(text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tintFromHexWKB(text) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloatFromHexWKB(text) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttextFromHexWKB(text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_from_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Output + *****************************************************************************/ + +CREATE FUNCTION asText(tbool) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tbool[]) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Temporalarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(tint) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tint[]) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Temporalarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(tfloat, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(tfloat[], maxdecimaldigits int4 DEFAULT 15) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Temporalarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asText(ttext) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asText(ttext[]) + RETURNS text[] + AS 'MODULE_PATHNAME', 'Temporalarr_as_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asMFJSON(temp tbool, options int4 DEFAULT 0, + flags int4 DEFAULT 0) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asMFJSON(temp tint, options int4 DEFAULT 0, + flags int4 DEFAULT 0) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asMFJSON(temp tfloat, options int4 DEFAULT 0, + flags int4 DEFAULT 0, maxdecimaldigits int4 DEFAULT 15) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asMFJSON(temp ttext, options int4 DEFAULT 0, + flags int4 DEFAULT 0) + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_mfjson' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION asBinary(tbool, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tint, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(tfloat, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asBinary(ttext, endianenconding text DEFAULT '') + RETURNS bytea + AS 'MODULE_PATHNAME', 'Temporal_as_wkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION asHexWKB(tbool, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(tint, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(tfloat, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION asHexWKB(ttext, endianenconding text DEFAULT '') + RETURNS text + AS 'MODULE_PATHNAME', 'Temporal_as_hexwkb' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/025_temporal_tile.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/025_temporal_tile.in.sql new file mode 100644 index 0000000..491dbef --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/025_temporal_tile.in.sql @@ -0,0 +1,316 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bin and tile functions for temporal types + * @note The time bin function are inspired from TimescaleDB + * https://docs.timescale.com/api/latest/hyperfunctions/time_bucket/ + */ + +/***************************************************************************** + * Bins + *****************************************************************************/ + +CREATE FUNCTION bins(intspan, vsize int, vorigin int DEFAULT 0) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Span_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(bigintspan, vsize bigint, vorigin int DEFAULT 0) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Span_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(floatspan, vsize float, vorigin float DEFAULT 0.0) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Span_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION bins(datespan, tsize interval, + torigin date DEFAULT '2000-01-01') + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Span_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(tstzspan, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Span_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE FUNCTION bins(intspanset, vsize int, vorigin int DEFAULT 0) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Spanset_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(bigintspanset, vsize bigint, vorigin int DEFAULT 0) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Spanset_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(floatspanset, vsize float, vorigin float DEFAULT 0.0) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Spanset_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION bins(datespanset, tsize interval, + torigin date DEFAULT '2000-01-01') + RETURNS datespan[] + AS 'MODULE_PATHNAME', 'Spanset_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION bins(tstzspanset, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Spanset_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE FUNCTION getBin("value" integer, size integer, origin integer DEFAULT 0) + RETURNS intspan + AS 'MODULE_PATHNAME', 'Value_bin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getBin("value" bigint, size bigint, origin bigint DEFAULT 0) + RETURNS bigintspan + AS 'MODULE_PATHNAME', 'Value_bin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getBin("value" float, size float, origin float DEFAULT 0.0) + RETURNS floatspan + AS 'MODULE_PATHNAME', 'Value_bin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getBin(date, interval, date DEFAULT '2000-01-03') + RETURNS datespan + AS 'MODULE_PATHNAME', 'Date_bin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION getBin(timestamptz, interval, timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Timestamptz_bin' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION timeBins(tbool, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_time_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeBins(tint, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_time_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeBins(tfloat, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_time_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeBins(ttext, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_time_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION valueBins(tint, vsize int, vorigin int DEFAULT 0) + RETURNS intspan[] + AS 'MODULE_PATHNAME', 'Tnumber_value_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION valueBins(tfloat, vsize float, vorigin float DEFAULT 0.0) + RETURNS floatspan[] + AS 'MODULE_PATHNAME', 'Tnumber_value_bins' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Multidimensional tiling + *****************************************************************************/ + +CREATE TYPE index_tbox AS ( + index integer, + tile tbox +); + +CREATE FUNCTION valueTiles(tbox, vsize float, vorigin float DEFAULT 0.0) + RETURNS SETOF index_tbox + AS 'MODULE_PATHNAME', 'Tbox_value_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION timeTiles(tbox, duration interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF index_tbox + AS 'MODULE_PATHNAME', 'Tbox_time_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION valueTimeTiles(tbox, vsize float, duration interval, + vorigin float DEFAULT 0.0, torigin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF index_tbox + AS 'MODULE_PATHNAME', 'Tbox_value_time_tiles' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE FUNCTION getValueTile(v float, vsize float, vorigin float DEFAULT 0.0) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_get_value_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getTBoxTimeTile(t timestamptz, duration interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_get_time_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION getValueTimeTile(v float, t timestamptz, vsize float, + duration interval, vorigin float DEFAULT 0.0, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_get_value_time_tile' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Boxes + *****************************************************************************/ + +CREATE FUNCTION valueBoxes(tint, vsize int, vorigin int DEFAULT 0) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_value_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION valueBoxes(tfloat, vsize float, vorigin float DEFAULT 0.0) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_value_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION timeBoxes(tint, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeBoxes(tfloat, tsize interval, + torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +CREATE FUNCTION valueTimeBoxes(tint, vsize int, tsize interval, + vorigin int DEFAULT 0, torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_value_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION valueTimeBoxes(tfloat, vsize float, tsize interval, + vorigin float DEFAULT 0.0, torigin timestamptz DEFAULT '2000-01-03') + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_value_time_boxes' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/***************************************************************************** + * Splitting + *****************************************************************************/ + +CREATE TYPE number_tint AS ( + number integer, + tnumber tint +); +CREATE TYPE number_tfloat AS ( + number float, + tnumber tfloat +); + +CREATE FUNCTION valueSplit(tint, size integer, origin integer DEFAULT 0) + RETURNS SETOF number_tint + AS 'MODULE_PATHNAME', 'Tnumber_value_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION valueSplit(tfloat, size float, origin float DEFAULT 0.0) + RETURNS SETOF number_tfloat + AS 'MODULE_PATHNAME', 'Tnumber_value_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE TYPE time_tbool AS ( + time timestamptz, + temp tbool +); +CREATE TYPE time_tint AS ( + time timestamptz, + temp tint +); +CREATE TYPE time_tfloat AS ( + time timestamptz, + temp tfloat +); +CREATE TYPE time_ttext AS ( + time timestamptz, + temp ttext +); + +CREATE FUNCTION timeSplit(tbool, size interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF time_tbool + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeSplit(tint, size interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF time_tint + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeSplit(tfloat, size interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF time_tfloat + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION timeSplit(ttext, size interval, + origin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF time_ttext + AS 'MODULE_PATHNAME', 'Temporal_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + +CREATE TYPE number_time_tint AS ( + number integer, + time timestamptz, + tnumber tint +); +CREATE TYPE number_time_tfloat AS ( + number float, + time timestamptz, + tnumber tfloat +); + +CREATE FUNCTION valueTimeSplit(tint, size integer, duration interval, + vorigin integer DEFAULT 0, torigin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF number_time_tint + AS 'MODULE_PATHNAME', 'Tnumber_value_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; +CREATE FUNCTION valueTimeSplit(tfloat, size float, duration interval, + vorigin float DEFAULT 0.0, torigin timestamptz DEFAULT '2000-01-03') + RETURNS SETOF number_time_tfloat + AS 'MODULE_PATHNAME', 'Tnumber_value_time_split' + LANGUAGE C IMMUTABLE PARALLEL SAFE STRICT; + +/*****************************************************************************/ + + diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/026_tnumber_mathfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/026_tnumber_mathfuncs.in.sql new file mode 100644 index 0000000..3c5bc3b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/026_tnumber_mathfuncs.in.sql @@ -0,0 +1,424 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal mathematic functions and operators + */ + +/***************************************************************************** + * Temporal addition + *****************************************************************************/ + +/* integer + */ + +CREATE FUNCTION tnumber_add(integer, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Add_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = + +); + +/*****************************************************************************/ + +/* float + */ + +CREATE FUNCTION tnumber_add(float, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Add_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = + +); + +/*****************************************************************************/ +/* tint + */ + +CREATE FUNCTION tnumber_add(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Add_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_add(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Add_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = + +); + +/*****************************************************************************/ +/* tfloat + */ + +CREATE FUNCTION tnumber_add(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Add_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_add(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Add_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = + +); +CREATE OPERATOR + ( + PROCEDURE = tnumber_add, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = + +); + +/***************************************************************************** + * Temporal subtraction + *****************************************************************************/ + +/* integer - */ + +CREATE FUNCTION tnumber_sub(integer, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Sub_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = integer, RIGHTARG = tint +); + +/*****************************************************************************/ + +/* tint - */ + +CREATE FUNCTION tnumber_sub(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Sub_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_sub(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Sub_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = tint, RIGHTARG = integer +); +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = tint, RIGHTARG = tint +); + +/*****************************************************************************/ + +/* float - */ + +CREATE FUNCTION tnumber_sub(float, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Sub_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = float, RIGHTARG = tfloat +); + +/*****************************************************************************/ + +/* tfloat - */ + +CREATE FUNCTION tnumber_sub(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Sub_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_sub(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Sub_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = tfloat, RIGHTARG = float +); +CREATE OPERATOR - ( + PROCEDURE = tnumber_sub, + LEFTARG = tfloat, RIGHTARG = tfloat +); + +/***************************************************************************** + * Temporal multiplication + *****************************************************************************/ + +/* integer * */ + +CREATE FUNCTION tnumber_mul(integer, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Mul_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = * +); + +/*****************************************************************************/ +/* tint * */ + +CREATE FUNCTION tnumber_mul(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Mul_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_mul(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Mul_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = * +); + +/*****************************************************************************/ + +/* float * */ + +CREATE FUNCTION tnumber_mul(float, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Mul_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = * +); + +/*****************************************************************************/ +/* tfloat * */ + +CREATE FUNCTION tnumber_mul(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Mul_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_mul(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Mul_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = * +); +CREATE OPERATOR * ( + PROCEDURE = tnumber_mul, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = * +); + +/***************************************************************************** + * Temporal division + *****************************************************************************/ + +/* integer / */ + +CREATE FUNCTION tnumber_div(integer, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Div_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = integer, RIGHTARG = tint +); + +/*****************************************************************************/ +/* tint / */ + +CREATE FUNCTION tnumber_div(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Div_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_div(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Div_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = tint, RIGHTARG = integer +); +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = tint, RIGHTARG = tint +); + +/*****************************************************************************/ + +/* float / */ + +CREATE FUNCTION tnumber_div(float, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Div_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = float, RIGHTARG = tfloat +); + +/*****************************************************************************/ + +CREATE FUNCTION tnumber_div(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Div_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_div(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Div_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = tfloat, RIGHTARG = float +); +CREATE OPERATOR / ( + PROCEDURE = tnumber_div, + LEFTARG = tfloat, RIGHTARG = tfloat +); + +/******************************************************************************/ + +CREATE FUNCTION abs(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_abs' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION abs(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_abs' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION deltaValue(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_delta_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION deltaValue(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_delta_value' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION floor(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_floor' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION ceil(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_ceil' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION round(tfloat, integer DEFAULT 0) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION round(tfloat[], integer DEFAULT 0) + RETURNS tfloat[] + AS 'MODULE_PATHNAME', 'Temporalarr_round' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION degrees(float, bool DEFAULT FALSE) + RETURNS float + AS 'MODULE_PATHNAME', 'Float_degrees' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION degrees(tfloat, bool DEFAULT FALSE) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_degrees' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION radians(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_radians' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION angularDifference(float, float) + RETURNS float + AS 'MODULE_PATHNAME', 'Float_angular_difference' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION trend(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_trend' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION trend(tfloat) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tnumber_trend' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION derivative(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_derivative' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION exp(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_exp' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION ln(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_ln' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION log10(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tfloat_log10' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/028_tbool_boolops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/028_tbool_boolops.in.sql new file mode 100644 index 0000000..50cba9b --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/028_tbool_boolops.in.sql @@ -0,0 +1,124 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal Boolean function and operators + */ + +/***************************************************************************** + * Temporal and + *****************************************************************************/ + +CREATE FUNCTION tbool_and(boolean, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tand_bool_tbool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbool_and(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tand_tbool_bool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbool_and(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tand_tbool_tbool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR & ( + PROCEDURE = tbool_and, + LEFTARG = boolean, RIGHTARG = tbool, + COMMUTATOR = & +); +CREATE OPERATOR & ( + PROCEDURE = tbool_and, + LEFTARG = tbool, RIGHTARG = boolean, + COMMUTATOR = & +); +CREATE OPERATOR & ( + PROCEDURE = tbool_and, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = & +); + +/***************************************************************************** + * Temporal or + *****************************************************************************/ + +CREATE FUNCTION tbool_or(boolean, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tor_bool_tbool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbool_or(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tor_tbool_bool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbool_or(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tor_tbool_tbool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR | ( + PROCEDURE = tbool_or, + LEFTARG = boolean, RIGHTARG = tbool, + COMMUTATOR = | +); +CREATE OPERATOR | ( + PROCEDURE = tbool_or, + LEFTARG = tbool, RIGHTARG = boolean, + COMMUTATOR = | +); +CREATE OPERATOR | ( + PROCEDURE = tbool_or, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = | +); + +/***************************************************************************** + * Temporal not + *****************************************************************************/ + +CREATE FUNCTION tbool_not(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tnot_tbool' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~ ( + PROCEDURE = tbool_not, RIGHTARG = tbool +); + +/***************************************************************************** + * Temporal when + *****************************************************************************/ + +-- when is a reserved word in SQL +CREATE FUNCTION whenTrue(tbool) + RETURNS tstzspanset + AS 'MODULE_PATHNAME', 'Tbool_when_true' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/029_ttext_textfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/029_ttext_textfuncs.in.sql new file mode 100644 index 0000000..2264269 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/029_ttext_textfuncs.in.sql @@ -0,0 +1,84 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal text functions + */ + +/***************************************************************************** + * Temporal text concatenation + *****************************************************************************/ + +CREATE FUNCTION ttext_cat(text, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Textcat_text_ttext' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext_cat(ttext, text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Textcat_ttext_text' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext_cat(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Textcat_ttext_ttext' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR || ( + PROCEDURE = ttext_cat, + LEFTARG = text, RIGHTARG = ttext +); +CREATE OPERATOR || ( + PROCEDURE = ttext_cat, + LEFTARG = ttext, RIGHTARG = text +); +CREATE OPERATOR || ( + PROCEDURE = ttext_cat, + LEFTARG = ttext, RIGHTARG = ttext +); + +/****************************************************************************** + * Temporal upper/lower case + *****************************************************************************/ + +CREATE FUNCTION upper(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Ttext_upper' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION lower(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Ttext_lower' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION initcap(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Ttext_initcap' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/030_temporal_compops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/030_temporal_compops.in.sql new file mode 100644 index 0000000..d16ec00 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/030_temporal_compops.in.sql @@ -0,0 +1,2026 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Comparison functions and operators for temporal types + * @note In this file we need both definitions of the functions with 2 and 3 + * parameters to be able to define the operators. This is not the case for + * the temporal relationships while a single definition of the functions with + * 3 parameters is enough + */ + +/***************************************************************************** + * Index Support Functions + *****************************************************************************/ + +CREATE FUNCTION tnumber_supportfn(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_supportfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Ever/Always Comparison Functions + *****************************************************************************/ + +CREATE FUNCTION ever_eq(boolean, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_base_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_base_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = boolean, RIGHTARG = tbool, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_eq(tbool, boolean) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_base' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_base' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tbool, RIGHTARG = boolean, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ne(boolean, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = boolean, RIGHTARG = tbool, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ne(tbool, boolean) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tbool, RIGHTARG = boolean, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION always_eq(boolean, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_base_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_base_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = boolean, RIGHTARG = tbool, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_eq(tbool, boolean) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_base' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_base' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tbool, RIGHTARG = boolean, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ne(boolean, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = boolean, RIGHTARG = tbool, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %<> ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ne(tbool, boolean) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tbool, RIGHTARG = boolean, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_lt(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?< ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_lt(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?< ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_le(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_le(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_gt(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?> ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_gt(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?> ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ge(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?>= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ge(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?>= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION always_lt(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %< ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_lt(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %< ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_le(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_le(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_gt(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %> ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_gt(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %> ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ge(integer, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(float, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(text, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %>= ( + LEFTARG = integer, RIGHTARG = tint, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = float, RIGHTARG = tfloat, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = text, RIGHTARG = ttext, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ge(tint, integer) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(tfloat, float) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(ttext, text) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %>= ( + LEFTARG = tint, RIGHTARG = integer, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = tfloat, RIGHTARG = float, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = ttext, RIGHTARG = text, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_eq(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_eq(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_eq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?= ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_eq, + NEGATOR = %<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_eq(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_temporal' + SUPPORT tnumber_supportfn + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_eq(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_eq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %= ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_eq, + NEGATOR = ?<>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ne(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ne(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<> ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_ne, + NEGATOR = %=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ne(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ne(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<> ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_ne, + NEGATOR = ?=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION ever_lt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_lt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?< ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?< ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_lt, + NEGATOR = %>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_le(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_le(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?<= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?<= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_le, + NEGATOR = %>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_lt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_lt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_lt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %< ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %< ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_lt, + NEGATOR = ?>=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_le(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_le(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_le_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %<= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %<= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_le, + NEGATOR = ?>, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_gt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_gt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_gt, + NEGATOR = %<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION ever_ge(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ever_ge(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Ever_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ?>= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ?>= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = ever_ge, + NEGATOR = %<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_gt(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_gt(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_gt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_gt, + NEGATOR = ?<=, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +CREATE FUNCTION always_ge(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION always_ge(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Always_ge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR %>= ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR %>= ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = always_ge, + NEGATOR = ?<, + RESTRICT = scalarltsel, JOIN = scalarltjoinsel +); + +/***************************************************************************** + * Temporal eq + *****************************************************************************/ + +-- Temporal boolean + +CREATE FUNCTION temporal_teq(boolean, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = boolean, RIGHTARG = tbool, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tbool, RIGHTARG = boolean, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_teq(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +-- float #= + +CREATE FUNCTION temporal_teq(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #= +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_teq(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_teq(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Teq_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #= +); +CREATE OPERATOR #= ( + PROCEDURE = temporal_teq, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #= +); + +/***************************************************************************** + * Temporal ne + *****************************************************************************/ + +-- Temporal boolean + +CREATE FUNCTION temporal_tne(boolean, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tbool, boolean) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = boolean, RIGHTARG = tbool, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tbool, RIGHTARG = boolean, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = #<> +); + +/*****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_tne(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #<> +); + +/*****************************************************************************/ + +-- Temporal float + +CREATE FUNCTION temporal_tne(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #<> +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_tne(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tne(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tne_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #<> +); +CREATE OPERATOR #<> ( + PROCEDURE = temporal_tne, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #<> +); + +/***************************************************************************** + * Temporal lt + *****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_tlt(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #> +); + +/*****************************************************************************/ + +-- Temporal float + +CREATE FUNCTION temporal_tlt(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #> +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_tlt(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tlt(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tlt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #> +); +CREATE OPERATOR #< ( + PROCEDURE = temporal_tlt, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #> +); + +/***************************************************************************** + * Temporal gt + *****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_tgt(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #< +); + +/*****************************************************************************/ + +-- Temporal float + +CREATE FUNCTION temporal_tgt(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(tfloat, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #< +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_tgt(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tgt(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tgt_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #< +); +CREATE OPERATOR #> ( + PROCEDURE = temporal_tgt, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #< +); + +/***************************************************************************** + * Temporal le + *****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_tle(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #>= +); + +/*****************************************************************************/ + +-- Temporal float + +CREATE FUNCTION temporal_tle(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #>= +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_tle(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tle(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tle_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #>= +); +CREATE OPERATOR #<= ( + PROCEDURE = temporal_tle, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #>= +); + +/***************************************************************************** + * Temporal ge + *****************************************************************************/ + +-- Temporal integer + +CREATE FUNCTION temporal_tge(integer, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(tint, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(tint, tint) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = #<= +); + +/*****************************************************************************/ + +-- Temporal float + +CREATE FUNCTION temporal_tge(float, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(tfloat, integer) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(tfloat, float) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(tfloat, tfloat) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = #<= +); + +/*****************************************************************************/ + +-- Temporal text + +CREATE FUNCTION temporal_tge(text, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_base_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(ttext, text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_base' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_tge(ttext, ttext) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Tge_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = text, RIGHTARG = ttext, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = ttext, RIGHTARG = text, + COMMUTATOR = #<= +); +CREATE OPERATOR #>= ( + PROCEDURE = temporal_tge, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = #<= +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/032_temporal_boxops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/032_temporal_boxops.in.sql new file mode 100644 index 0000000..adcc7f9 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/032_temporal_boxops.in.sql @@ -0,0 +1,1246 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Bounding tbox operators for temporal types + */ + +/***************************************************************************** + * Boxes functions + *****************************************************************************/ + +CREATE FUNCTION spans(tbool) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tint) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(tfloat) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION spans(ttext) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tboxes(tint) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tboxes(tfloat) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNSpans(tbool, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(tfloat, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNSpans(ttext, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNSpans(tbool, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tint, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(tfloat, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNSpans(ttext, integer) + RETURNS tstzspan[] + AS 'MODULE_PATHNAME', 'Temporal_split_each_n_spans' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitNTboxes(tint, integer) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_split_n_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitNTboxes(tfloat, integer) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_split_n_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION splitEachNTboxes(tint, integer) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_split_each_n_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION splitEachNTboxes(tfloat, integer) + RETURNS tbox[] + AS 'MODULE_PATHNAME', 'Tnumber_split_each_n_tboxes' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/***************************************************************************** + * Temporal boolean + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tbool, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tbool, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tbool, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tbool, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tbool, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tbool, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tbool, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tbool, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tbool, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tbool, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tbool, RIGHTARG = tbool, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * Temporal integer + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tint, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tint, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = intspan, RIGHTARG = tint, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tint, RIGHTARG = intspan, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tint, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tint, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = intspan, RIGHTARG = tint, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tint, RIGHTARG = intspan, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tint, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tint, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = intspan, RIGHTARG = tint, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tint, RIGHTARG = intspan, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tint, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tint, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = intspan, RIGHTARG = tint, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tint, RIGHTARG = intspan, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tint, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tint, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = intspan, RIGHTARG = tint, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tint, RIGHTARG = intspan, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * Temporal float + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = tfloat, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tfloat, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION temporal_overlaps(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = floatspan, RIGHTARG = tfloat, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tfloat, RIGHTARG = floatspan, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = &&, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = tfloat, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tfloat, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = floatspan, RIGHTARG = tfloat, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tfloat, RIGHTARG = floatspan, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = <@, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = tfloat, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tfloat, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = floatspan, RIGHTARG = tfloat, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tfloat, RIGHTARG = floatspan, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = @>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = tfloat, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tfloat, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = floatspan, RIGHTARG = tfloat, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tfloat, RIGHTARG = floatspan, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = ~=, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = tfloat, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tfloat, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = floatspan, RIGHTARG = tfloat, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tfloat, RIGHTARG = floatspan, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = -|-, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * Temporal text + *****************************************************************************/ + +CREATE FUNCTION temporal_overlaps(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overlaps(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overlaps_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = tstzspan, RIGHTARG = ttext, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = ttext, RIGHTARG = tstzspan, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR && ( + PROCEDURE = temporal_overlaps, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = &&, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contains(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contains(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contains_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = tstzspan, RIGHTARG = ttext, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = ttext, RIGHTARG = tstzspan, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR @> ( + PROCEDURE = temporal_contains, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = <@, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_contained(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_contained(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Contained_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = tstzspan, RIGHTARG = ttext, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = ttext, RIGHTARG = tstzspan, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR <@ ( + PROCEDURE = temporal_contained, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = @>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_same(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_same(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Same_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = tstzspan, RIGHTARG = ttext, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = ttext, RIGHTARG = tstzspan, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR ~= ( + PROCEDURE = temporal_same, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = ~=, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +CREATE FUNCTION temporal_adjacent(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_adjacent(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Adjacent_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = tstzspan, RIGHTARG = ttext, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = ttext, RIGHTARG = tstzspan, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR -|- ( + PROCEDURE = temporal_adjacent, + LEFTARG = ttext, RIGHTARG = ttext, + COMMUTATOR = -|-, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/034_temporal_posops.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/034_temporal_posops.in.sql new file mode 100644 index 0000000..4dde598 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/034_temporal_posops.in.sql @@ -0,0 +1,1248 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Relative position operators for 1D (time) and 2D (1D value + 1D time) + * temporal types + */ + +/***************************************************************************** + * tstzspan + *****************************************************************************/ + +/* tstzspan op tbool */ + +CREATE FUNCTION temporal_before(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tbool, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tbool, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tbool, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tbool, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* tstzspan op tint */ + +CREATE FUNCTION temporal_before(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tint, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tint, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tstzspan op tfloat */ + +CREATE FUNCTION temporal_before(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = tfloat, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = tfloat, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tstzspan op ttext */ + +CREATE FUNCTION temporal_before(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tstzspan, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tstzspan_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tstzspan, RIGHTARG = ttext, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tstzspan, RIGHTARG = ttext, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tstzspan, RIGHTARG = ttext, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tstzspan, RIGHTARG = ttext, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * intspan + *****************************************************************************/ + +/* intspan op tint */ + +CREATE FUNCTION temporal_left(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(intspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = intspan, RIGHTARG = tint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = intspan, RIGHTARG = tint, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = intspan, RIGHTARG = tint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = intspan, RIGHTARG = tint, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* intspan op tfloat */ + +CREATE FUNCTION temporal_left(intspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(intspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(intspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(intspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = intspan, RIGHTARG = tfloat, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = intspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = intspan, RIGHTARG = tfloat, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = intspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * floatspan + *****************************************************************************/ + +/* floatspan op tint */ + +CREATE FUNCTION temporal_left(floatspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(floatspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(floatspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(floatspan, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = floatspan, RIGHTARG = tint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = floatspan, RIGHTARG = tint, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = floatspan, RIGHTARG = tint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = floatspan, RIGHTARG = tint, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* floatspan op tfloat */ + +CREATE FUNCTION temporal_left(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(floatspan, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_numspan_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = floatspan, RIGHTARG = tfloat, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = floatspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = floatspan, RIGHTARG = tfloat, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = floatspan, RIGHTARG = tfloat, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * tbox + *****************************************************************************/ + +/* tbox op tint */ + +CREATE FUNCTION temporal_left(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tbox, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tbox, RIGHTARG = tint, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tbox op tfloat */ + +CREATE FUNCTION temporal_left(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tbox, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tbox, RIGHTARG = tfloat, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * tbool + *****************************************************************************/ + +/* tbool op tstzspan */ + +CREATE FUNCTION temporal_before(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tbool, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tbool, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tbool, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tbool, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tbool, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* tbool op tbool */ + +CREATE FUNCTION temporal_before(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tbool, tbool) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tbool, RIGHTARG = tbool, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/***************************************************************************** + * tint + *****************************************************************************/ + +/* tint op tstzspan */ + +CREATE FUNCTION temporal_before(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tint, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tint, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tint, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tint, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tint op intspan */ + +CREATE FUNCTION temporal_left(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tint, intspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tint, RIGHTARG = intspan, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tint, RIGHTARG = intspan, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tint, RIGHTARG = intspan, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tint, RIGHTARG = intspan, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tint op tbox */ + +CREATE FUNCTION temporal_left(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tint, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tint, RIGHTARG = tbox, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tint op tint */ + +CREATE FUNCTION temporal_left(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tint, tint) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tint, RIGHTARG = tint, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * tfloat + *****************************************************************************/ + +/* tfloat op tstzspan */ + +CREATE FUNCTION temporal_before(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tfloat, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = tfloat, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tfloat, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tfloat, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tfloat, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tfloat op floatspan */ + +CREATE FUNCTION temporal_left(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tfloat, floatspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_numspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tfloat, RIGHTARG = floatspan, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tfloat, RIGHTARG = floatspan, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tfloat, RIGHTARG = floatspan, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tfloat, RIGHTARG = floatspan, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tfloat op tbox */ + +CREATE FUNCTION temporal_left(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tfloat, tbox) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tfloat, RIGHTARG = tbox, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ + +/* tfloat op tfloat */ + +CREATE FUNCTION temporal_left(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Left_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overleft(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overleft_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_right(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Right_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overright(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overright_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_before(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(tfloat, tfloat) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR << ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_left, + COMMUTATOR = >>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &< ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_overleft, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR >> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_right, + COMMUTATOR = <<, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_overright, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR <<# ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_overbefore, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = tfloat, RIGHTARG = tfloat, + PROCEDURE = temporal_overafter, + RESTRICT = tnumber_sel, JOIN = tnumber_joinsel +); + +/***************************************************************************** + * ttext + *****************************************************************************/ + +/* ttext op tstzspan */ + +CREATE FUNCTION temporal_before(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(ttext, tstzspan) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_tstzspan' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = ttext, RIGHTARG = tstzspan, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = ttext, RIGHTARG = tstzspan, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = ttext, RIGHTARG = tstzspan, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = ttext, RIGHTARG = tstzspan, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = temporal_joinsel +); + +/*****************************************************************************/ + +/* ttext op ttext */ + +CREATE FUNCTION temporal_before(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Before_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overbefore(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overbefore_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_after(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'After_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_overafter(ttext, ttext) + RETURNS boolean + AS 'MODULE_PATHNAME', 'Overafter_temporal_temporal' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <<# ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_before, + COMMUTATOR = #>>, + RESTRICT = temporal_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR &<# ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_overbefore, + RESTRICT = temporal_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #>> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_after, + COMMUTATOR = <<#, + RESTRICT = temporal_sel, JOIN = tnumber_joinsel +); +CREATE OPERATOR #&> ( + LEFTARG = ttext, RIGHTARG = ttext, + PROCEDURE = temporal_overafter, + RESTRICT = temporal_sel, JOIN = tnumber_joinsel +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/036_tnumber_distance.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/036_tnumber_distance.in.sql new file mode 100644 index 0000000..93e0d03 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/036_tnumber_distance.in.sql @@ -0,0 +1,242 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Distance functions for temporal numbers + */ + +/***************************************************************************** + * Temporal distance + *****************************************************************************/ + +/* integer <-> */ + +CREATE FUNCTION tDistance(integer, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tdistance_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = <-> +); + +/*****************************************************************************/ + +/* float <-> */ + +CREATE FUNCTION tDistance(float, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = <-> +); + +/*****************************************************************************/ +/* tint <-> */ + +CREATE FUNCTION tDistance(tint, integer) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tdistance_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Tdistance_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = <-> +); + +/*****************************************************************************/ +/* tfloat <-> */ + +CREATE FUNCTION tDistance(tfloat, float) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tDistance(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tdistance_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = <-> +); +CREATE OPERATOR <-> ( + PROCEDURE = tDistance, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = <-> +); + +/***************************************************************************** + * Nearest approach distance + *****************************************************************************/ + +/* integer |=| */ + +CREATE FUNCTION nearestApproachDistance(integer, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = integer, RIGHTARG = tint, + COMMUTATOR = |=| +); + +/*****************************************************************************/ + +/* float |=| */ + +CREATE FUNCTION nearestApproachDistance(float, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_number_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = float, RIGHTARG = tfloat, + COMMUTATOR = |=| +); + +/*****************************************************************************/ + +/* tbox |=| */ + +CREATE FUNCTION nearestApproachDistance(tbox, tbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tbox_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tbox, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tbox, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tbox_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tbox, RIGHTARG = tbox, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tbox, RIGHTARG = tint, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tbox, RIGHTARG = tfloat, + COMMUTATOR = |=| +); + +/*****************************************************************************/ +/* tint |=| */ + +CREATE FUNCTION nearestApproachDistance(tint, integer) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tint, tbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tint, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tint, RIGHTARG = integer, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tint, RIGHTARG = tbox, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tint, RIGHTARG = tint, + COMMUTATOR = |=| +); + +/*****************************************************************************/ +/* tfloat |=| */ + +CREATE FUNCTION nearestApproachDistance(tfloat, float) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_number' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tfloat, tbox) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_tbox' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION nearestApproachDistance(tfloat, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'NAD_tnumber_tnumber' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tfloat, RIGHTARG = float, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tfloat, RIGHTARG = tbox, + COMMUTATOR = |=| +); +CREATE OPERATOR |=| ( + PROCEDURE = nearestApproachDistance, + LEFTARG = tfloat, RIGHTARG = tfloat, + COMMUTATOR = |=| +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/038_temporal_similarity.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/038_temporal_similarity.in.sql new file mode 100644 index 0000000..2b489ec --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/038_temporal_similarity.in.sql @@ -0,0 +1,89 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Similarity distance for temporal values + * @note Currently, the discrete Frechet distance, the Dynamic Time Warping + * (DTW) distance, and the Hausdorff distance are implemented + */ + +CREATE FUNCTION frechetDistance(tint, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_frechet_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION frechetDistance(tfloat, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_frechet_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dynTimeWarpDistance(tint, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dynTimeWarpDistance(tfloat, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION hausdorffDistance(tint, tint) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_hausdorff_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION hausdorffDistance(tfloat, tfloat) + RETURNS float + AS 'MODULE_PATHNAME', 'Temporal_hausdorff_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +CREATE TYPE warp AS ( + i integer, + j integer +); + +CREATE FUNCTION frechetDistancePath(tint, tint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_frechet_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION frechetDistancePath(tfloat, tfloat) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_frechet_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION dynTimeWarpPath(tint, tint) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION dynTimeWarpPath(tfloat, tfloat) + RETURNS SETOF warp + AS 'MODULE_PATHNAME', 'Temporal_dyntimewarp_path' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/040_temporal_aggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/040_temporal_aggfuncs.in.sql new file mode 100644 index 0000000..d984ca1 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/040_temporal_aggfuncs.in.sql @@ -0,0 +1,730 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Temporal aggregate functions + */ + +-- The function is not strict +CREATE FUNCTION temporal_extent_transfn(tstzspan, tbool) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_extent_transfn(tstzspan, ttext) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Temporal_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_extent_combinefn(tstzspan, tstzspan) + RETURNS tstzspan + AS 'MODULE_PATHNAME', 'Span_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(tbool) ( + SFUNC = temporal_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = temporal_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(ttext) ( + SFUNC = temporal_extent_transfn, + STYPE = tstzspan, + COMBINEFUNC = temporal_extent_combinefn, + PARALLEL = safe +); + +-- The function is not strict +CREATE FUNCTION tnumber_extent_transfn(tbox, tint) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tnumber_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tnumber_extent_transfn(tbox, tfloat) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tnumber_extent_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tnumber_extent_combinefn(tbox, tbox) + RETURNS tbox + AS 'MODULE_PATHNAME', 'Tbox_extent_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE extent(tint) ( + SFUNC = tnumber_extent_transfn, + STYPE = tbox, + COMBINEFUNC = tnumber_extent_combinefn, + PARALLEL = safe +); +CREATE AGGREGATE extent(tfloat) ( + SFUNC = tnumber_extent_transfn, + STYPE = tbox, + COMBINEFUNC = tnumber_extent_combinefn, + PARALLEL = safe +); + +/*****************************************************************************/ + +CREATE FUNCTION taggstate_serialize(internal) + RETURNS bytea + AS 'MODULE_PATHNAME', 'Taggstate_serialize' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION taggstate_deserialize(bytea, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Taggstate_deserialize' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, timestamptz) + RETURNS internal + AS 'MODULE_PATHNAME', 'Timestamptz_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcount_transfn(internal, tstzset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tstzset_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcount_transfn(internal, tstzspan) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tstzspan_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tcount_transfn(internal, tstzspanset) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tstzspanset_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tcount_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tagg_finalfn(internal) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE tcount(timestamptz) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tcount(tstzset) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tcount(tstzspan) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tcount(tstzspanset) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tbool) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tbool_tand_transfn(internal, tbool) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbool_tand_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tbool_tand_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbool_tand_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tbool_tor_transfn(internal, tbool) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbool_tor_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tbool_tor_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbool_tor_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tbool_tagg_finalfn(internal) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE tcount(tbool) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tand(tbool) ( + SFUNC = tbool_tand_transfn, + STYPE = internal, + COMBINEFUNC = tbool_tand_combinefn, + FINALFUNC = tbool_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tor(tbool) ( + SFUNC = tbool_tor_transfn, + STYPE = internal, + COMBINEFUNC = tbool_tor_combinefn, + FINALFUNC = tbool_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tint_tmin_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tmin_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tmin_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tmin_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tmax_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tmax_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tmax_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tmax_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tsum_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tsum_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_tsum_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_tsum_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tavg_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_tavg_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tavg_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_tavg_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tavg_finalfn(internal) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Tnumber_tavg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE tcount(tint) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tmin(tint) ( + SFUNC = tint_tmin_transfn, + STYPE = internal, + COMBINEFUNC = tint_tmin_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tmax(tint) ( + SFUNC = tint_tmax_transfn, + STYPE = internal, + COMBINEFUNC = tint_tmax_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tsum(tint) ( + SFUNC = tint_tsum_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tavg(tint) ( + SFUNC = tavg_transfn, + STYPE = internal, + COMBINEFUNC = tavg_combinefn, + FINALFUNC = tavg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION tfloat_tmin_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tmin_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tmin_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tmin_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tmax_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tmax_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tmax_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tmax_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tsum_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tsum_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tsum_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_tsum_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_tagg_finalfn(internal) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +-- The function is not strict +CREATE FUNCTION tavg_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_tavg_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE tcount(tfloat) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tmin(tfloat) ( + SFUNC = tfloat_tmin_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tmin_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tmax(tfloat) ( + SFUNC = tfloat_tmax_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tmax_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tsum(tfloat) ( + SFUNC = tfloat_tsum_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tsum_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tavg(tfloat) ( + SFUNC = tavg_transfn, + STYPE = internal, + COMBINEFUNC = tavg_combinefn, + FINALFUNC = tavg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tcount_transfn(internal, ttext) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_tcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION ttext_tmin_transfn(internal, ttext) + RETURNS internal + AS 'MODULE_PATHNAME', 'Ttext_tmin_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttext_tmin_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Ttext_tmin_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttext_tmax_transfn(internal, ttext) + RETURNS internal + AS 'MODULE_PATHNAME', 'Ttext_tmax_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttext_tmax_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Ttext_tmax_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION ttext_tagg_finalfn(internal) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_tagg_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE tcount(ttext) ( + SFUNC = tcount_transfn, + STYPE = internal, + COMBINEFUNC = tcount_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +CREATE AGGREGATE tmin(ttext) ( + SFUNC = ttext_tmin_transfn, + STYPE = internal, + COMBINEFUNC = ttext_tmin_combinefn, + FINALFUNC = ttext_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE tmax(ttext) ( + SFUNC = ttext_tmax_transfn, + STYPE = internal, + COMBINEFUNC = ttext_tmax_combinefn, + FINALFUNC = ttext_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION temporal_merge_transfn(internal, tbool) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_merge_transfn(internal, tint) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_merge_transfn(internal, tfloat) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_merge_transfn(internal, ttext) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_merge_combinefn(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_merge_combinefn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE merge(tbool) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tbool_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); +CREATE AGGREGATE merge(tint) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); +CREATE AGGREGATE merge(tfloat) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); +CREATE AGGREGATE merge(ttext) ( + SFUNC = temporal_merge_transfn, + STYPE = internal, + COMBINEFUNC = temporal_merge_combinefn, + FINALFUNC = ttext_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = safe +); + +/***************************************************************************** + * Append aggregate functions + *****************************************************************************/ + +-- Default interpolation based on the base type +CREATE FUNCTION temporal_app_tinst_transfn(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- Interpolation given by the user +CREATE FUNCTION temporal_app_tinst_transfn(tbool, tbool, interp text) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tint, tint, interp text) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tfloat, tfloat, interp text) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(ttext, ttext, interp text) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +-- These functions are not strict +CREATE FUNCTION temporal_app_tinst_transfn(tbool, tbool, interp text, + maxt interval) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tint, tint, interp text, + maxdist float, maxt interval) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(tfloat, tfloat, interp text, + maxdist float, maxt interval) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tinst_transfn(ttext, ttext, interp text, + maxt interval) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_app_tinst_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE FUNCTION temporal_append_finalfn(tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_append_finalfn(tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_append_finalfn(tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION temporal_append_finalfn(ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_append_finalfn' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE AGGREGATE appendInstant(tbool) ( + SFUNC = temporal_app_tinst_transfn(tbool, tbool), + STYPE = tbool, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tbool, interp text) ( + SFUNC = temporal_app_tinst_transfn(tbool, tbool, text), + STYPE = tbool, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tbool, interp text, maxt interval) ( + SFUNC = temporal_app_tinst_transfn(tbool, tbool, text, maxt), + STYPE = tbool, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tint) ( + SFUNC = temporal_app_tinst_transfn(tint, tint), + STYPE = tint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tint, interp text) ( + SFUNC = temporal_app_tinst_transfn(tint, tint, text), + STYPE = tint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tint, interp text, maxdist float, + maxt interval) ( + SFUNC = temporal_app_tinst_transfn(tint, tint, text, maxdist, maxt), + STYPE = tint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(tfloat) ( + SFUNC = temporal_app_tinst_transfn(tfloat, tfloat), + STYPE = tfloat, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tfloat, interp text) ( + SFUNC = temporal_app_tinst_transfn(tfloat, tfloat, text), + STYPE = tfloat, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(tfloat, interp text, maxdist float, + maxt interval) ( + SFUNC = temporal_app_tinst_transfn(tfloat, tfloat, text, maxdist, maxt), + STYPE = tfloat, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +CREATE AGGREGATE appendInstant(ttext) ( + SFUNC = temporal_app_tinst_transfn(ttext, ttext), + STYPE = ttext, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(ttext, interp text) ( + SFUNC = temporal_app_tinst_transfn(ttext, ttext, text), + STYPE = ttext, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendInstant(ttext, interp text, maxt interval) ( + SFUNC = temporal_app_tinst_transfn(ttext, ttext, text, maxt), + STYPE = ttext, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ + +-- The function is not STRICT +CREATE FUNCTION temporal_app_tseq_transfn(tbool, tbool) + RETURNS tbool + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tseq_transfn(tint, tint) + RETURNS tint + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tseq_transfn(tfloat, tfloat) + RETURNS tfloat + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION temporal_app_tseq_transfn(ttext, ttext) + RETURNS ttext + AS 'MODULE_PATHNAME', 'Temporal_app_tseq_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE appendSequence(tbool) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tbool, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendSequence(tint) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tint, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendSequence(tfloat) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = tfloat, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); +CREATE AGGREGATE appendSequence(ttext) ( + SFUNC = temporal_app_tseq_transfn, + STYPE = ttext, + FINALFUNC = temporal_append_finalfn, + PARALLEL = safe +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/042_temporal_waggfuncs.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/042_temporal_waggfuncs.in.sql new file mode 100644 index 0000000..b07a0e4 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/042_temporal_waggfuncs.in.sql @@ -0,0 +1,173 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Moving window temporal aggregate functions + */ + +-- The function is not strict +CREATE FUNCTION tint_wmin_transfn(internal, tint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_wmin_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_wmax_transfn(internal, tint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_wmax_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tint_wsum_transfn(internal, tint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tint_wsum_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wcount_transfn(internal, tint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wavg_transfn(internal, tint, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_wavg_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wmin(tint, interval) ( + SFUNC = tint_wmin_transfn, + STYPE = internal, + COMBINEFUNC = tint_tmin_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wmax(tint, interval) ( + SFUNC = tint_wmax_transfn, + STYPE = internal, + COMBINEFUNC = tint_tmax_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wsum(tint, interval) ( + SFUNC = tint_wsum_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wcount(tint, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wavg(tint, interval) ( + SFUNC = wavg_transfn, + STYPE = internal, + COMBINEFUNC = tavg_combinefn, + FINALFUNC = tavg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ + +-- The function is not strict +CREATE FUNCTION tfloat_wmin_transfn(internal, tfloat, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_wmin_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_wmax_transfn(internal, tfloat, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_wmax_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION tfloat_wsum_transfn(internal, tfloat, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tfloat_wsum_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wcount_transfn(internal, tfloat, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_wcount_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; +CREATE FUNCTION wavg_transfn(internal, tfloat, interval) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_wavg_transfn' + LANGUAGE C IMMUTABLE PARALLEL SAFE; + +CREATE AGGREGATE wmin(tfloat, interval) ( + SFUNC = tfloat_wmin_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tmin_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wmax(tfloat, interval) ( + SFUNC = tfloat_wmax_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tmax_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wsum(tfloat, interval) ( + SFUNC = tfloat_wsum_transfn, + STYPE = internal, + COMBINEFUNC = tfloat_tsum_combinefn, + FINALFUNC = tfloat_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wcount(tfloat, interval) ( + SFUNC = wcount_transfn, + STYPE = internal, + COMBINEFUNC = tint_tsum_combinefn, + FINALFUNC = tint_tagg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); +CREATE AGGREGATE wavg(tfloat, interval) ( + SFUNC = wavg_transfn, + STYPE = internal, + COMBINEFUNC = tavg_combinefn, + FINALFUNC = tavg_finalfn, + SERIALFUNC = taggstate_serialize, + DESERIALFUNC = taggstate_deserialize, + PARALLEL = SAFE +); + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/043_temporal_gist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/043_temporal_gist.in.sql new file mode 100644 index 0000000..7c2a01c --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/043_temporal_gist.in.sql @@ -0,0 +1,392 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief R-tree GiST index for temporal types + */ + +/******************************************************************************/ + +CREATE FUNCTION tbox_gist_consistent(internal, tbox, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Tnumber_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gist_union(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbox_gist_union' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gist_penalty(internal, internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbox_gist_penalty' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gist_picksplit(internal, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbox_gist_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gist_same(tbox, tbox, internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tbox_gist_same' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_gist_distance(internal, tbox, smallint, oid, internal) + RETURNS float8 + AS 'MODULE_PATHNAME', 'Tbox_gist_distance' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE FUNCTION tbool_gist_consistent(internal, tbool, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbool_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tint_gist_consistent(internal, tint, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Tnumber_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tint_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION tfloat_gist_consistent(internal, tfloat, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Tnumber_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tfloat_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION ttext_gist_consistent(internal, ttext, smallint, oid, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Span_gist_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION ttext_gist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_gist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbox_rtree_ops + DEFAULT FOR TYPE tbox USING gist AS + -- strictly left + OPERATOR 1 << (tbox, tbox), + OPERATOR 1 << (tbox, tint), + OPERATOR 1 << (tbox, tfloat), + -- overlaps or left + OPERATOR 2 &< (tbox, tbox), + OPERATOR 2 &< (tbox, tint), + OPERATOR 2 &< (tbox, tfloat), + -- overlaps + OPERATOR 3 && (tbox, tbox), + OPERATOR 3 && (tbox, tint), + OPERATOR 3 && (tbox, tfloat), + -- overlaps or right + OPERATOR 4 &> (tbox, tbox), + OPERATOR 4 &> (tbox, tint), + OPERATOR 4 &> (tbox, tfloat), + -- strictly right + OPERATOR 5 >> (tbox, tbox), + OPERATOR 5 >> (tbox, tint), + OPERATOR 5 >> (tbox, tfloat), + -- same + OPERATOR 6 ~= (tbox, tbox), + OPERATOR 6 ~= (tbox, tint), + OPERATOR 6 ~= (tbox, tfloat), + -- contains + OPERATOR 7 @> (tbox, tbox), + OPERATOR 7 @> (tbox, tint), + OPERATOR 7 @> (tbox, tfloat), + -- contained by + OPERATOR 8 <@ (tbox, tbox), + OPERATOR 8 <@ (tbox, tint), + OPERATOR 8 <@ (tbox, tfloat), + -- adjacent + OPERATOR 17 -|- (tbox, tbox), + OPERATOR 17 -|- (tbox, tint), + OPERATOR 17 -|- (tbox, tfloat), + -- overlaps or before + OPERATOR 28 &<# (tbox, tbox), + OPERATOR 28 &<# (tbox, tint), + OPERATOR 28 &<# (tbox, tfloat), + -- strictly before + OPERATOR 29 <<# (tbox, tbox), + OPERATOR 29 <<# (tbox, tint), + OPERATOR 29 <<# (tbox, tfloat), + -- strictly after + OPERATOR 30 #>> (tbox, tbox), + OPERATOR 30 #>> (tbox, tint), + OPERATOR 30 #>> (tbox, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tbox, tbox), + OPERATOR 31 #&> (tbox, tint), + OPERATOR 31 #&> (tbox, tfloat), + -- functions + FUNCTION 1 tbox_gist_consistent(internal, tbox, smallint, oid, internal), + FUNCTION 2 tbox_gist_union(internal, internal), + FUNCTION 5 tbox_gist_penalty(internal, internal, internal), + FUNCTION 6 tbox_gist_picksplit(internal, internal), + FUNCTION 7 tbox_gist_same(tbox, tbox, internal), + FUNCTION 8 tbox_gist_distance(internal, tbox, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbool_rtree_ops + DEFAULT FOR TYPE tbool USING gist AS + STORAGE tstzspan, + -- overlaps + OPERATOR 3 && (tbool, tstzspan), + OPERATOR 3 && (tbool, tbool), + -- same + OPERATOR 6 ~= (tbool, tstzspan), + OPERATOR 6 ~= (tbool, tbool), + -- contains + OPERATOR 7 @> (tbool, tstzspan), + OPERATOR 7 @> (tbool, tbool), + -- contained by + OPERATOR 8 <@ (tbool, tstzspan), + OPERATOR 8 <@ (tbool, tbool), + -- adjacent + OPERATOR 17 -|- (tbool, tstzspan), + OPERATOR 17 -|- (tbool, tbool), + -- overlaps or before + OPERATOR 28 &<# (tbool, tstzspan), + OPERATOR 28 &<# (tbool, tbool), + -- strictly before + OPERATOR 29 <<# (tbool, tstzspan), + OPERATOR 29 <<# (tbool, tbool), + -- strictly after + OPERATOR 30 #>> (tbool, tstzspan), + OPERATOR 30 #>> (tbool, tbool), + -- overlaps or after + OPERATOR 31 #&> (tbool, tstzspan), + OPERATOR 31 #&> (tbool, tbool), + -- functions + FUNCTION 1 tbool_gist_consistent(internal, tbool, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 tbool_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(tstzspan, tstzspan, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tint_rtree_ops + DEFAULT FOR TYPE tint USING gist AS + STORAGE tbox, + -- strictly left + OPERATOR 1 << (tint, intspan), + OPERATOR 1 << (tint, tbox), + OPERATOR 1 << (tint, tint), + -- overlaps or left + OPERATOR 2 &< (tint, intspan), + OPERATOR 2 &< (tint, tbox), + OPERATOR 2 &< (tint, tint), + -- overlaps + OPERATOR 3 && (tint, intspan), + OPERATOR 3 && (tint, tstzspan), + OPERATOR 3 && (tint, tbox), + OPERATOR 3 && (tint, tint), + -- overlaps or right + OPERATOR 4 &> (tint, intspan), + OPERATOR 4 &> (tint, tbox), + OPERATOR 4 &> (tint, tint), + -- strictly right + OPERATOR 5 >> (tint, intspan), + OPERATOR 5 >> (tint, tbox), + OPERATOR 5 >> (tint, tint), + -- same + OPERATOR 6 ~= (tint, intspan), + OPERATOR 6 ~= (tint, tstzspan), + OPERATOR 6 ~= (tint, tbox), + OPERATOR 6 ~= (tint, tint), + -- contains + OPERATOR 7 @> (tint, intspan), + OPERATOR 7 @> (tint, tstzspan), + OPERATOR 7 @> (tint, tbox), + OPERATOR 7 @> (tint, tint), + -- contained by + OPERATOR 8 <@ (tint, intspan), + OPERATOR 8 <@ (tint, tstzspan), + OPERATOR 8 <@ (tint, tbox), + OPERATOR 8 <@ (tint, tint), + -- adjacent + OPERATOR 17 -|- (tint, intspan), + OPERATOR 17 -|- (tint, tstzspan), + OPERATOR 17 -|- (tint, tbox), + OPERATOR 17 -|- (tint, tint), + -- nearest approach distance + OPERATOR 25 |=| (tint, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tint, tint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tint, tstzspan), + OPERATOR 28 &<# (tint, tbox), + OPERATOR 28 &<# (tint, tint), + -- strictly before + OPERATOR 29 <<# (tint, tstzspan), + OPERATOR 29 <<# (tint, tbox), + OPERATOR 29 <<# (tint, tint), + -- strictly after + OPERATOR 30 #>> (tint, tstzspan), + OPERATOR 30 #>> (tint, tbox), + OPERATOR 30 #>> (tint, tint), + -- overlaps or after + OPERATOR 31 #&> (tint, tstzspan), + OPERATOR 31 #&> (tint, tbox), + OPERATOR 31 #&> (tint, tint), + -- functions + FUNCTION 1 tint_gist_consistent(internal, tint, smallint, oid, internal), + FUNCTION 2 tbox_gist_union(internal, internal), + FUNCTION 3 tint_gist_compress(internal), + FUNCTION 5 tbox_gist_penalty(internal, internal, internal), + FUNCTION 6 tbox_gist_picksplit(internal, internal), + FUNCTION 7 tbox_gist_same(tbox, tbox, internal), + FUNCTION 8 tbox_gist_distance(internal, tbox, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tfloat_rtree_ops + DEFAULT FOR TYPE tfloat USING gist AS + STORAGE tbox, + -- strictly left + OPERATOR 1 << (tfloat, floatspan), + OPERATOR 1 << (tfloat, tbox), + OPERATOR 1 << (tfloat, tfloat), + -- overlaps or left + OPERATOR 2 &< (tfloat, floatspan), + OPERATOR 2 &< (tfloat, tbox), + OPERATOR 2 &< (tfloat, tfloat), + -- overlaps + OPERATOR 3 && (tfloat, floatspan), + OPERATOR 3 && (tfloat, tstzspan), + OPERATOR 3 && (tfloat, tbox), + OPERATOR 3 && (tfloat, tfloat), + -- overlaps or right + OPERATOR 4 &> (tfloat, floatspan), + OPERATOR 4 &> (tfloat, tbox), + OPERATOR 4 &> (tfloat, tfloat), + -- strictly right + OPERATOR 5 >> (tfloat, floatspan), + OPERATOR 5 >> (tfloat, tbox), + OPERATOR 5 >> (tfloat, tfloat), + -- same + OPERATOR 6 ~= (tfloat, floatspan), + OPERATOR 6 ~= (tfloat, tstzspan), + OPERATOR 6 ~= (tfloat, tbox), + OPERATOR 6 ~= (tfloat, tfloat), + -- contains + OPERATOR 7 @> (tfloat, floatspan), + OPERATOR 7 @> (tfloat, tstzspan), + OPERATOR 7 @> (tfloat, tbox), + OPERATOR 7 @> (tfloat, tfloat), + -- contained by + OPERATOR 8 <@ (tfloat, floatspan), + OPERATOR 8 <@ (tfloat, tstzspan), + OPERATOR 8 <@ (tfloat, tbox), + OPERATOR 8 <@ (tfloat, tfloat), + -- adjacent + OPERATOR 17 -|- (tfloat, floatspan), + OPERATOR 17 -|- (tfloat, tstzspan), + OPERATOR 17 -|- (tfloat, tbox), + OPERATOR 17 -|- (tfloat, tfloat), + -- nearest approach distance + OPERATOR 25 |=| (tfloat, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tfloat, tfloat) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tfloat, tstzspan), + OPERATOR 28 &<# (tfloat, tbox), + OPERATOR 28 &<# (tfloat, tfloat), + -- strictly before + OPERATOR 29 <<# (tfloat, tstzspan), + OPERATOR 29 <<# (tfloat, tbox), + OPERATOR 29 <<# (tfloat, tfloat), + -- strictly after + OPERATOR 30 #>> (tfloat, tstzspan), + OPERATOR 30 #>> (tfloat, tbox), + OPERATOR 30 #>> (tfloat, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tfloat, tstzspan), + OPERATOR 31 #&> (tfloat, tbox), + OPERATOR 31 #&> (tfloat, tfloat), + -- functions + FUNCTION 1 tfloat_gist_consistent(internal, tfloat, smallint, oid, internal), + FUNCTION 2 tbox_gist_union(internal, internal), + FUNCTION 3 tfloat_gist_compress(internal), + FUNCTION 5 tbox_gist_penalty(internal, internal, internal), + FUNCTION 6 tbox_gist_picksplit(internal, internal), + FUNCTION 7 tbox_gist_same(tbox, tbox, internal), + FUNCTION 8 tbox_gist_distance(internal, tbox, smallint, oid, internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS ttext_rtree_ops + DEFAULT FOR TYPE ttext USING gist AS + STORAGE tstzspan, + -- overlaps + OPERATOR 3 && (ttext, tstzspan), + OPERATOR 3 && (ttext, ttext), + -- same + OPERATOR 6 ~= (ttext, tstzspan), + OPERATOR 6 ~= (ttext, ttext), + -- contains + OPERATOR 7 @> (ttext, tstzspan), + OPERATOR 7 @> (ttext, ttext), + -- contained by + OPERATOR 8 <@ (ttext, tstzspan), + OPERATOR 8 <@ (ttext, ttext), + -- adjacent + OPERATOR 17 -|- (ttext, tstzspan), + OPERATOR 17 -|- (ttext, ttext), + -- overlaps or before + OPERATOR 28 &<# (ttext, tstzspan), + OPERATOR 28 &<# (ttext, ttext), + -- strictly before + OPERATOR 29 <<# (ttext, tstzspan), + OPERATOR 29 <<# (ttext, ttext), + -- strictly after + OPERATOR 30 #>> (ttext, tstzspan), + OPERATOR 30 #>> (ttext, ttext), + -- overlaps or after + OPERATOR 31 #&> (ttext, tstzspan), + OPERATOR 31 #&> (ttext, ttext), + -- functions + FUNCTION 1 ttext_gist_consistent(internal, ttext, smallint, oid, internal), + FUNCTION 2 span_gist_union(internal, internal), + FUNCTION 3 ttext_gist_compress(internal), + FUNCTION 5 span_gist_penalty(internal, internal, internal), + FUNCTION 6 span_gist_picksplit(internal, internal), + FUNCTION 7 span_gist_same(tstzspan, tstzspan, internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/044_temporal_spgist.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/044_temporal_spgist.in.sql new file mode 100644 index 0000000..a3dc407 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/044_temporal_spgist.in.sql @@ -0,0 +1,654 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Quad-tree and k-d tree SP-GiST indexes for temporal types + */ + +/******************************************************************************/ + +CREATE FUNCTION tbox_spgist_config(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_spgist_config' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_quadtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_quadtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_quadtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_quadtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_quadtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_quadtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_spgist_leaf_consistent(internal, internal) + RETURNS bool + AS 'MODULE_PATHNAME', 'Tbox_spgist_leaf_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tnumber_spgist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Tnumber_spgist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbox_quadtree_ops + DEFAULT FOR TYPE tbox USING spgist AS + -- strictly left + OPERATOR 1 << (tbox, tbox), + OPERATOR 1 << (tbox, tint), + OPERATOR 1 << (tbox, tfloat), + -- overlaps or left + OPERATOR 2 &< (tbox, tbox), + OPERATOR 2 &< (tbox, tint), + OPERATOR 2 &< (tbox, tfloat), + -- overlaps + OPERATOR 3 && (tbox, tbox), + OPERATOR 3 && (tbox, tint), + OPERATOR 3 && (tbox, tfloat), + -- overlaps or right + OPERATOR 4 &> (tbox, tbox), + OPERATOR 4 &> (tbox, tint), + OPERATOR 4 &> (tbox, tfloat), + -- strictly right + OPERATOR 5 >> (tbox, tbox), + OPERATOR 5 >> (tbox, tint), + OPERATOR 5 >> (tbox, tfloat), + -- same + OPERATOR 6 ~= (tbox, tbox), + OPERATOR 6 ~= (tbox, tint), + OPERATOR 6 ~= (tbox, tfloat), + -- contains + OPERATOR 7 @> (tbox, tbox), + OPERATOR 7 @> (tbox, tint), + OPERATOR 7 @> (tbox, tfloat), + -- contained by + OPERATOR 8 <@ (tbox, tbox), + OPERATOR 8 <@ (tbox, tint), + OPERATOR 8 <@ (tbox, tfloat), + -- adjacent + OPERATOR 17 -|- (tbox, tbox), + OPERATOR 17 -|- (tbox, tint), + OPERATOR 17 -|- (tbox, tfloat), + -- overlaps or before + OPERATOR 28 &<# (tbox, tbox), + OPERATOR 28 &<# (tbox, tint), + OPERATOR 28 &<# (tbox, tfloat), + -- strictly before + OPERATOR 29 <<# (tbox, tbox), + OPERATOR 29 <<# (tbox, tint), + OPERATOR 29 <<# (tbox, tfloat), + -- strictly after + OPERATOR 30 #>> (tbox, tbox), + OPERATOR 30 #>> (tbox, tint), + OPERATOR 30 #>> (tbox, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tbox, tbox), + OPERATOR 31 #&> (tbox, tint), + OPERATOR 31 #&> (tbox, tfloat), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_quadtree_choose(internal, internal), + FUNCTION 3 tbox_quadtree_picksplit(internal, internal), + FUNCTION 4 tbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal); + +/*****************************************************************************/ + +CREATE FUNCTION tbox_kdtree_choose(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_kdtree_choose' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_kdtree_picksplit(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_kdtree_picksplit' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +CREATE FUNCTION tbox_kdtree_inner_consistent(internal, internal) + RETURNS void + AS 'MODULE_PATHNAME', 'Tbox_kdtree_inner_consistent' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbox_kdtree_ops + FOR TYPE tbox USING spgist AS + -- strictly left + OPERATOR 1 << (tbox, tbox), + OPERATOR 1 << (tbox, tint), + OPERATOR 1 << (tbox, tfloat), + -- overlaps or left + OPERATOR 2 &< (tbox, tbox), + OPERATOR 2 &< (tbox, tint), + OPERATOR 2 &< (tbox, tfloat), + -- overlaps + OPERATOR 3 && (tbox, tbox), + OPERATOR 3 && (tbox, tint), + OPERATOR 3 && (tbox, tfloat), + -- overlaps or right + OPERATOR 4 &> (tbox, tbox), + OPERATOR 4 &> (tbox, tint), + OPERATOR 4 &> (tbox, tfloat), + -- strictly right + OPERATOR 5 >> (tbox, tbox), + OPERATOR 5 >> (tbox, tint), + OPERATOR 5 >> (tbox, tfloat), + -- same + OPERATOR 6 ~= (tbox, tbox), + OPERATOR 6 ~= (tbox, tint), + OPERATOR 6 ~= (tbox, tfloat), + -- contains + OPERATOR 7 @> (tbox, tbox), + OPERATOR 7 @> (tbox, tint), + OPERATOR 7 @> (tbox, tfloat), + -- contained by + OPERATOR 8 <@ (tbox, tbox), + OPERATOR 8 <@ (tbox, tint), + OPERATOR 8 <@ (tbox, tfloat), + -- adjacent + OPERATOR 17 -|- (tbox, tbox), + OPERATOR 17 -|- (tbox, tint), + OPERATOR 17 -|- (tbox, tfloat), + -- overlaps or before + OPERATOR 28 &<# (tbox, tbox), + OPERATOR 28 &<# (tbox, tint), + OPERATOR 28 &<# (tbox, tfloat), + -- strictly before + OPERATOR 29 <<# (tbox, tbox), + OPERATOR 29 <<# (tbox, tint), + OPERATOR 29 <<# (tbox, tfloat), + -- strictly after + OPERATOR 30 #>> (tbox, tbox), + OPERATOR 30 #>> (tbox, tint), + OPERATOR 30 #>> (tbox, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tbox, tbox), + OPERATOR 31 #&> (tbox, tint), + OPERATOR 31 #&> (tbox, tfloat), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_kdtree_choose(internal, internal), + FUNCTION 3 tbox_kdtree_picksplit(internal, internal), + FUNCTION 4 tbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal); + +/******************************************************************************/ + +CREATE FUNCTION temporal_spgist_compress(internal) + RETURNS internal + AS 'MODULE_PATHNAME', 'Temporal_spgist_compress' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbool_quadtree_ops + DEFAULT FOR TYPE tbool USING spgist AS + -- overlaps + OPERATOR 3 && (tbool, tstzspan), + OPERATOR 3 && (tbool, tbool), + -- same + OPERATOR 6 ~= (tbool, tstzspan), + OPERATOR 6 ~= (tbool, tbool), + -- contains + OPERATOR 7 @> (tbool, tstzspan), + OPERATOR 7 @> (tbool, tbool), + -- contained by + OPERATOR 8 <@ (tbool, tstzspan), + OPERATOR 8 <@ (tbool, tbool), + -- adjacent + OPERATOR 17 -|- (tbool, tstzspan), + OPERATOR 17 -|- (tbool, tbool), + -- overlaps or before + OPERATOR 28 &<# (tbool, tstzspan), + OPERATOR 28 &<# (tbool, tbool), + -- strictly before + OPERATOR 29 <<# (tbool, tstzspan), + OPERATOR 29 <<# (tbool, tbool), + -- strictly after + OPERATOR 30 #>> (tbool, tstzspan), + OPERATOR 30 #>> (tbool, tbool), + -- overlaps or after + OPERATOR 31 #&> (tbool, tstzspan), + OPERATOR 31 #&> (tbool, tbool), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 temporal_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tbool_kdtree_ops + FOR TYPE tbool USING spgist AS + -- overlaps + OPERATOR 3 && (tbool, tstzspan), + OPERATOR 3 && (tbool, tbool), + -- same + OPERATOR 6 ~= (tbool, tstzspan), + OPERATOR 6 ~= (tbool, tbool), + -- contains + OPERATOR 7 @> (tbool, tstzspan), + OPERATOR 7 @> (tbool, tbool), + -- contained by + OPERATOR 8 <@ (tbool, tstzspan), + OPERATOR 8 <@ (tbool, tbool), + -- adjacent + OPERATOR 17 -|- (tbool, tstzspan), + OPERATOR 17 -|- (tbool, tbool), + -- overlaps or before + OPERATOR 28 &<# (tbool, tstzspan), + OPERATOR 28 &<# (tbool, tbool), + -- strictly before + OPERATOR 29 <<# (tbool, tstzspan), + OPERATOR 29 <<# (tbool, tbool), + -- strictly after + OPERATOR 30 #>> (tbool, tstzspan), + OPERATOR 30 #>> (tbool, tbool), + -- overlaps or after + OPERATOR 31 #&> (tbool, tstzspan), + OPERATOR 31 #&> (tbool, tbool), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 temporal_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tint_quadtree_ops + DEFAULT FOR TYPE tint USING spgist AS + -- strictly left + OPERATOR 1 << (tint, intspan), + OPERATOR 1 << (tint, tbox), + OPERATOR 1 << (tint, tint), + -- overlaps or left + OPERATOR 2 &< (tint, intspan), + OPERATOR 2 &< (tint, tbox), + OPERATOR 2 &< (tint, tint), + -- overlaps + OPERATOR 3 && (tint, intspan), + OPERATOR 3 && (tint, tstzspan), + OPERATOR 3 && (tint, tbox), + OPERATOR 3 && (tint, tint), + -- overlaps or right + OPERATOR 4 &> (tint, intspan), + OPERATOR 4 &> (tint, tbox), + OPERATOR 4 &> (tint, tint), + -- strictly right + OPERATOR 5 >> (tint, intspan), + OPERATOR 5 >> (tint, tbox), + OPERATOR 5 >> (tint, tint), + -- same + OPERATOR 6 ~= (tint, intspan), + OPERATOR 6 ~= (tint, tstzspan), + OPERATOR 6 ~= (tint, tbox), + OPERATOR 6 ~= (tint, tint), + -- contains + OPERATOR 7 @> (tint, intspan), + OPERATOR 7 @> (tint, tstzspan), + OPERATOR 7 @> (tint, tbox), + OPERATOR 7 @> (tint, tint), + -- contained by + OPERATOR 8 <@ (tint, intspan), + OPERATOR 8 <@ (tint, tstzspan), + OPERATOR 8 <@ (tint, tbox), + OPERATOR 8 <@ (tint, tint), + -- adjacent + OPERATOR 17 -|- (tint, intspan), + OPERATOR 17 -|- (tint, tstzspan), + OPERATOR 17 -|- (tint, tbox), + OPERATOR 17 -|- (tint, tint), + -- nearest approach distance + OPERATOR 25 |=| (tint, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tint, tint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tint, tstzspan), + OPERATOR 28 &<# (tint, tbox), + OPERATOR 28 &<# (tint, tint), + -- strictly before + OPERATOR 29 <<# (tint, tstzspan), + OPERATOR 29 <<# (tint, tbox), + OPERATOR 29 <<# (tint, tint), + -- strictly after + OPERATOR 30 #>> (tint, tstzspan), + OPERATOR 30 #>> (tint, tbox), + OPERATOR 30 #>> (tint, tint), + -- overlaps or after + OPERATOR 31 #&> (tint, tstzspan), + OPERATOR 31 #&> (tint, tbox), + OPERATOR 31 #&> (tint, tint), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_quadtree_choose(internal, internal), + FUNCTION 3 tbox_quadtree_picksplit(internal, internal), + FUNCTION 4 tbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tnumber_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tint_kdtree_ops + FOR TYPE tint USING spgist AS + -- strictly left + OPERATOR 1 << (tint, intspan), + OPERATOR 1 << (tint, tbox), + OPERATOR 1 << (tint, tint), + -- overlaps or left + OPERATOR 2 &< (tint, intspan), + OPERATOR 2 &< (tint, tbox), + OPERATOR 2 &< (tint, tint), + -- overlaps + OPERATOR 3 && (tint, intspan), + OPERATOR 3 && (tint, tstzspan), + OPERATOR 3 && (tint, tbox), + OPERATOR 3 && (tint, tint), + -- overlaps or right + OPERATOR 4 &> (tint, intspan), + OPERATOR 4 &> (tint, tbox), + OPERATOR 4 &> (tint, tint), + -- strictly right + OPERATOR 5 >> (tint, intspan), + OPERATOR 5 >> (tint, tbox), + OPERATOR 5 >> (tint, tint), + -- same + OPERATOR 6 ~= (tint, intspan), + OPERATOR 6 ~= (tint, tstzspan), + OPERATOR 6 ~= (tint, tbox), + OPERATOR 6 ~= (tint, tint), + -- contains + OPERATOR 7 @> (tint, intspan), + OPERATOR 7 @> (tint, tstzspan), + OPERATOR 7 @> (tint, tbox), + OPERATOR 7 @> (tint, tint), + -- contained by + OPERATOR 8 <@ (tint, intspan), + OPERATOR 8 <@ (tint, tstzspan), + OPERATOR 8 <@ (tint, tbox), + OPERATOR 8 <@ (tint, tint), + -- adjacent + OPERATOR 17 -|- (tint, intspan), + OPERATOR 17 -|- (tint, tstzspan), + OPERATOR 17 -|- (tint, tbox), + OPERATOR 17 -|- (tint, tint), + -- nearest approach distance + OPERATOR 25 |=| (tint, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tint, tint) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tint, tstzspan), + OPERATOR 28 &<# (tint, tbox), + OPERATOR 28 &<# (tint, tint), + -- strictly before + OPERATOR 29 <<# (tint, tstzspan), + OPERATOR 29 <<# (tint, tbox), + OPERATOR 29 <<# (tint, tint), + -- strictly after + OPERATOR 30 #>> (tint, tstzspan), + OPERATOR 30 #>> (tint, tbox), + OPERATOR 30 #>> (tint, tint), + -- overlaps or after + OPERATOR 31 #&> (tint, tstzspan), + OPERATOR 31 #&> (tint, tbox), + OPERATOR 31 #&> (tint, tint), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_kdtree_choose(internal, internal), + FUNCTION 3 tbox_kdtree_picksplit(internal, internal), + FUNCTION 4 tbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tnumber_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tfloat_quadtree_ops + DEFAULT FOR TYPE tfloat USING spgist AS + -- strictly left + OPERATOR 1 << (tfloat, floatspan), + OPERATOR 1 << (tfloat, tbox), + OPERATOR 1 << (tfloat, tfloat), + -- overlaps or left + OPERATOR 2 &< (tfloat, floatspan), + OPERATOR 2 &< (tfloat, tbox), + OPERATOR 2 &< (tfloat, tfloat), + -- overlaps + OPERATOR 3 && (tfloat, floatspan), + OPERATOR 3 && (tfloat, tstzspan), + OPERATOR 3 && (tfloat, tbox), + OPERATOR 3 && (tfloat, tfloat), + -- overlaps or right + OPERATOR 4 &> (tfloat, floatspan), + OPERATOR 4 &> (tfloat, tbox), + OPERATOR 4 &> (tfloat, tfloat), + -- strictly right + OPERATOR 5 >> (tfloat, floatspan), + OPERATOR 5 >> (tfloat, tbox), + OPERATOR 5 >> (tfloat, tfloat), + -- same + OPERATOR 6 ~= (tfloat, floatspan), + OPERATOR 6 ~= (tfloat, tstzspan), + OPERATOR 6 ~= (tfloat, tbox), + OPERATOR 6 ~= (tfloat, tfloat), + -- contains + OPERATOR 7 @> (tfloat, floatspan), + OPERATOR 7 @> (tfloat, tstzspan), + OPERATOR 7 @> (tfloat, tbox), + OPERATOR 7 @> (tfloat, tfloat), + -- contained by + OPERATOR 8 <@ (tfloat, floatspan), + OPERATOR 8 <@ (tfloat, tstzspan), + OPERATOR 8 <@ (tfloat, tbox), + OPERATOR 8 <@ (tfloat, tfloat), + -- adjacent + OPERATOR 17 -|- (tfloat, floatspan), + OPERATOR 17 -|- (tfloat, tstzspan), + OPERATOR 17 -|- (tfloat, tbox), + OPERATOR 17 -|- (tfloat, tfloat), + -- nearest approach distance + OPERATOR 25 |=| (tfloat, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tfloat, tfloat) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tfloat, tstzspan), + OPERATOR 28 &<# (tfloat, tbox), + OPERATOR 28 &<# (tfloat, tfloat), + -- strictly before + OPERATOR 29 <<# (tfloat, tstzspan), + OPERATOR 29 <<# (tfloat, tbox), + OPERATOR 29 <<# (tfloat, tfloat), + -- strictly after + OPERATOR 30 #>> (tfloat, tstzspan), + OPERATOR 30 #>> (tfloat, tbox), + OPERATOR 30 #>> (tfloat, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tfloat, tstzspan), + OPERATOR 31 #&> (tfloat, tbox), + OPERATOR 31 #&> (tfloat, tfloat), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_quadtree_choose(internal, internal), + FUNCTION 3 tbox_quadtree_picksplit(internal, internal), + FUNCTION 4 tbox_quadtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tnumber_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS tfloat_kdtree_ops + FOR TYPE tfloat USING spgist AS + -- strictly left + OPERATOR 1 << (tfloat, floatspan), + OPERATOR 1 << (tfloat, tbox), + OPERATOR 1 << (tfloat, tfloat), + -- overlaps or left + OPERATOR 2 &< (tfloat, floatspan), + OPERATOR 2 &< (tfloat, tbox), + OPERATOR 2 &< (tfloat, tfloat), + -- overlaps + OPERATOR 3 && (tfloat, floatspan), + OPERATOR 3 && (tfloat, tstzspan), + OPERATOR 3 && (tfloat, tbox), + OPERATOR 3 && (tfloat, tfloat), + -- overlaps or right + OPERATOR 4 &> (tfloat, floatspan), + OPERATOR 4 &> (tfloat, tbox), + OPERATOR 4 &> (tfloat, tfloat), + -- strictly right + OPERATOR 5 >> (tfloat, floatspan), + OPERATOR 5 >> (tfloat, tbox), + OPERATOR 5 >> (tfloat, tfloat), + -- same + OPERATOR 6 ~= (tfloat, floatspan), + OPERATOR 6 ~= (tfloat, tstzspan), + OPERATOR 6 ~= (tfloat, tbox), + OPERATOR 6 ~= (tfloat, tfloat), + -- contains + OPERATOR 7 @> (tfloat, floatspan), + OPERATOR 7 @> (tfloat, tstzspan), + OPERATOR 7 @> (tfloat, tbox), + OPERATOR 7 @> (tfloat, tfloat), + -- contained by + OPERATOR 8 <@ (tfloat, floatspan), + OPERATOR 8 <@ (tfloat, tstzspan), + OPERATOR 8 <@ (tfloat, tbox), + OPERATOR 8 <@ (tfloat, tfloat), + -- adjacent + OPERATOR 17 -|- (tfloat, floatspan), + OPERATOR 17 -|- (tfloat, tstzspan), + OPERATOR 17 -|- (tfloat, tbox), + OPERATOR 17 -|- (tfloat, tfloat), + -- nearest approach distance + OPERATOR 25 |=| (tfloat, tbox) FOR ORDER BY pg_catalog.float_ops, + OPERATOR 25 |=| (tfloat, tfloat) FOR ORDER BY pg_catalog.float_ops, + -- overlaps or before + OPERATOR 28 &<# (tfloat, tstzspan), + OPERATOR 28 &<# (tfloat, tbox), + OPERATOR 28 &<# (tfloat, tfloat), + -- strictly before + OPERATOR 29 <<# (tfloat, tstzspan), + OPERATOR 29 <<# (tfloat, tbox), + OPERATOR 29 <<# (tfloat, tfloat), + -- strictly after + OPERATOR 30 #>> (tfloat, tstzspan), + OPERATOR 30 #>> (tfloat, tbox), + OPERATOR 30 #>> (tfloat, tfloat), + -- overlaps or after + OPERATOR 31 #&> (tfloat, tstzspan), + OPERATOR 31 #&> (tfloat, tbox), + OPERATOR 31 #&> (tfloat, tfloat), + -- functions + FUNCTION 1 tbox_spgist_config(internal, internal), + FUNCTION 2 tbox_kdtree_choose(internal, internal), + FUNCTION 3 tbox_kdtree_picksplit(internal, internal), + FUNCTION 4 tbox_kdtree_inner_consistent(internal, internal), + FUNCTION 5 tbox_spgist_leaf_consistent(internal, internal), + FUNCTION 6 tnumber_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS ttext_quadtree_ops + DEFAULT FOR TYPE ttext USING spgist AS + -- overlaps + OPERATOR 3 && (ttext, tstzspan), + OPERATOR 3 && (ttext, ttext), + -- same + OPERATOR 6 ~= (ttext, tstzspan), + OPERATOR 6 ~= (ttext, ttext), + -- contains + OPERATOR 7 @> (ttext, tstzspan), + OPERATOR 7 @> (ttext, ttext), + -- contained by + OPERATOR 8 <@ (ttext, tstzspan), + OPERATOR 8 <@ (ttext, ttext), + -- adjacent + OPERATOR 17 -|- (ttext, tstzspan), + OPERATOR 17 -|- (ttext, ttext), + -- overlaps or before + OPERATOR 28 &<# (ttext, tstzspan), + OPERATOR 28 &<# (ttext, ttext), + -- strictly before + OPERATOR 29 <<# (ttext, tstzspan), + OPERATOR 29 <<# (ttext, ttext), + -- strictly after + OPERATOR 30 #>> (ttext, tstzspan), + OPERATOR 30 #>> (ttext, ttext), + -- overlaps or after + OPERATOR 31 #&> (ttext, tstzspan), + OPERATOR 31 #&> (ttext, ttext), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_quadtree_choose(internal, internal), + FUNCTION 3 span_quadtree_picksplit(internal, internal), + FUNCTION 4 span_quadtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 temporal_spgist_compress(internal); + +/******************************************************************************/ + +CREATE OPERATOR CLASS ttext_kdtree_ops + FOR TYPE ttext USING spgist AS + -- overlaps + OPERATOR 3 && (ttext, tstzspan), + OPERATOR 3 && (ttext, ttext), + -- same + OPERATOR 6 ~= (ttext, tstzspan), + OPERATOR 6 ~= (ttext, ttext), + -- contains + OPERATOR 7 @> (ttext, tstzspan), + OPERATOR 7 @> (ttext, ttext), + -- contained by + OPERATOR 8 <@ (ttext, tstzspan), + OPERATOR 8 <@ (ttext, ttext), + -- adjacent + OPERATOR 17 -|- (ttext, tstzspan), + OPERATOR 17 -|- (ttext, ttext), + -- overlaps or before + OPERATOR 28 &<# (ttext, tstzspan), + OPERATOR 28 &<# (ttext, ttext), + -- strictly before + OPERATOR 29 <<# (ttext, tstzspan), + OPERATOR 29 <<# (ttext, ttext), + -- strictly after + OPERATOR 30 #>> (ttext, tstzspan), + OPERATOR 30 #>> (ttext, ttext), + -- overlaps or after + OPERATOR 31 #&> (ttext, tstzspan), + OPERATOR 31 #&> (ttext, ttext), + -- functions + FUNCTION 1 tstzspan_spgist_config(internal, internal), + FUNCTION 2 span_kdtree_choose(internal, internal), + FUNCTION 3 span_kdtree_picksplit(internal, internal), + FUNCTION 4 span_kdtree_inner_consistent(internal, internal), + FUNCTION 5 span_spgist_leaf_consistent(internal, internal), + FUNCTION 6 temporal_spgist_compress(internal); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/046_temporal_analytics.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/046_temporal_analytics.in.sql new file mode 100644 index 0000000..e976f97 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/046_temporal_analytics.in.sql @@ -0,0 +1,57 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Analytic functions for temporal types + */ + +/*****************************************************************************/ + +CREATE FUNCTION minDistSimplify(tfloat, float) +RETURNS tfloat +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION minTimeDeltaSimplify(tfloat, interval) +RETURNS tfloat +AS 'MODULE_PATHNAME', 'Temporal_simplify_min_tdelta' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION maxDistSimplify(tfloat, float, boolean DEFAULT TRUE) +RETURNS tfloat +AS 'MODULE_PATHNAME', 'Temporal_simplify_max_dist' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +CREATE FUNCTION douglasPeuckerSimplify(tfloat, float, boolean DEFAULT TRUE) +RETURNS tfloat +AS 'MODULE_PATHNAME', 'Temporal_simplify_dp' +LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +/*****************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/999_oid_cache.in.sql b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/999_oid_cache.in.sql new file mode 100644 index 0000000..b3a3853 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/999_oid_cache.in.sql @@ -0,0 +1,50 @@ +/***************************************************************************** + * + * This MobilityDB code is provided under The PostgreSQL License. + * Copyright (c) 2016-2025, Université libre de Bruxelles and MobilityDB + * contributors + * + * MobilityDB includes portions of PostGIS version 3 source code released + * under the GNU General Public License (GPLv2 or later). + * Copyright (c) 2001-2025, PostGIS contributors + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose, without fee, and without a written + * agreement is hereby granted, provided that the above copyright notice and + * this paragraph and the following two paragraphs appear in all copies. + * + * IN NO EVENT SHALL UNIVERSITE LIBRE DE BRUXELLES BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, + * EVEN IF UNIVERSITE LIBRE DE BRUXELLES HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * UNIVERSITE LIBRE DE BRUXELLES SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON + * AN "AS IS" BASIS, AND UNIVERSITE LIBRE DE BRUXELLES HAS NO OBLIGATIONS TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + *****************************************************************************/ + +/** + * @file + * @brief Routine that pre-computes the type and operator Oid cache and store + * them in a global array and a hash table + */ + +CREATE TABLE mobilitydb_opcache ( + opnum INT, + ltypnum INT, + rtypnum INT, + opid Oid +); + +CREATE FUNCTION fill_oid_cache() + RETURNS VOID + AS 'MODULE_PATHNAME', 'fill_oid_cache' + LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; + +SELECT fill_oid_cache(); + +/******************************************************************************/ diff --git a/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/CMakeLists.txt b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/CMakeLists.txt new file mode 100644 index 0000000..c1b8086 --- /dev/null +++ b/kafka-streams-app/tools/parity/meos-ref/mobilitydb/sql/temporal/CMakeLists.txt @@ -0,0 +1,39 @@ +SET(LOCAL_FILES + 001_set + 002_set_ops + 003_span + 005_span_ops + 007_spanset + 009_spanset_ops + 011_span_indexes + 012_spanset_indexes + 013_set_indexes + 015_span_aggfuncs + 019_geo_constructors + 021_tbox + 022_temporal + 023_temporal_inout + 025_temporal_tile + 026_tnumber_mathfuncs + 028_tbool_boolops + 029_ttext_textfuncs + 030_temporal_compops + 032_temporal_boxops + 034_temporal_posops + 036_tnumber_distance + 038_temporal_similarity + 040_temporal_aggfuncs + 042_temporal_waggfuncs + 043_temporal_gist + 044_temporal_spgist + 046_temporal_analytics + 999_oid_cache + ) + +foreach (f ${LOCAL_FILES}) + process_file(${f} ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}) + configure_file(${CMAKE_CURRENT_BINARY_DIR}/${f}.sql.in ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql @ONLY) + list(APPEND PACKAGE_SQL_FILES ${CMAKE_BINARY_DIR}/MobilityDB/sql/${f}.sql) +endforeach() + +set(PROJECT_SQL_FILES ${PROJECT_SQL_FILES} ${PACKAGE_SQL_FILES} PARENT_SCOPE) diff --git a/kafka-streams-app/tools/parity/parity_audit.py b/kafka-streams-app/tools/parity/parity_audit.py new file mode 100644 index 0000000..24266b0 --- /dev/null +++ b/kafka-streams-app/tools/parity/parity_audit.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python3 +"""Symbol-level parity audit for the MobilityKafka generated MEOS facade. + +Measures, per type family, how much of the MEOS public-header function surface +the generated facade (org.mobilitydb.kafka.meos.MeosOps*) exposes, cross-checked +against the JMEOS jar export set so a method only counts when it is genuinely +bindable. + +Reference surface = the MEOS public C API (meos/include/meos*.h, excluding the +meos_internal*.h headers). This is the surface JMEOS mirrors and the facade +delegates to, so it is the exact denominator for a Flink binding. A second view +maps the facade against the MobilityDB SQL layer's underlying C symbols for +comparability with the SQL-surface bindings. + +Coverage reported here is STATIC: the facade method exists and binds a JMEOS +symbol of matching arity. Runtime behaviour is exercised separately by the +per-family smoke tests. + +Usage: + python3 tools/parity/parity_audit.py \ + --meos-include /path/to/MobilityDB/meos/include \ + --jar jar/JMEOS.jar \ + --facade src/main/java/org/mobilitydb/kafka/meos \ + --mdb-sql /path/to/MobilityDB/mobilitydb/sql \ + --out docs/parity-status.md +""" +import argparse, re, os, glob, subprocess, collections +from datetime import date + +PUBLIC_HEADERS = ["meos.h", "meos_geo.h", "meos_cbuffer.h", + "meos_npoint.h", "meos_pose.h", "meos_rgeo.h", +"meos_h3.h"] +FAMILY = {"meos.h": "core temporal / set / span / spanset / tbox", + "meos_geo.h": "geo (tgeo / tpoint / stbox)", + "meos_cbuffer.h": "cbuffer", "meos_npoint.h": "npoint", + "meos_pose.h": "pose", "meos_rgeo.h": "rgeo", + "meos_h3.h": "h3 / th3index"} + +_DECL = re.compile(r'^\s*extern\s+.+?\b([a-z][A-Za-z0-9_]*)\s*\(', re.M) +_PUBSTATIC = re.compile(r'public static [A-Za-z0-9_.<>\[\]]+ ([a-z0-9_]+)\(') + +# MobilityDB SQL out-of-scope bucketing (PG-only; no MEOS/Flink equivalent). +OOS_SECTIONS = { + "temporal/011_span_indexes.in.sql", "temporal/012_spanset_indexes.in.sql", + "temporal/013_set_indexes.in.sql", "temporal/019_geo_constructors.in.sql", + "temporal/043_temporal_gist.in.sql", "temporal/044_temporal_spgist.in.sql", + "temporal/999_oid_cache.in.sql", "geo/073_tgeo_gist.in.sql", + "geo/073_tpoint_gist.in.sql", "geo/074_tgeo_spgist.in.sql", + "geo/074_tpoint_spgist.in.sql", "cbuffer/166_tcbuffer_indexes.in.sql", + "npoint/092_tnpoint_gin.in.sql", "npoint/098_tnpoint_indexes.in.sql", + "pose/114_tpose_indexes.in.sql", "rgeo/134_trgeo_indexes.in.sql", +} +OOS_SUFFIXES = ("_in", "_out", "_recv", "_send", "_typmod_in", "_typmod_out", + "_transfn", "_combinefn", "_finalfn", "_serialize", "_deserialize", + "_sel", "_joinsel", "_supportfn", "_analyze", + "_cmp", "_eq", "_ne", "_lt", "_le", "_gt", "_ge", "_hash", "_hash_extended") +OOS_NAMES = {"range", "multirange", "create_trip", "transform_gk"} + + +def jmeos_symbols(jar): + out = subprocess.run(["javap", "-classpath", jar, "-p", + "functions.GeneratedFunctions"], + capture_output=True, text=True).stdout + return set(re.findall(r'\b([a-z][a-z0-9_]+)\(', out)) + + +def facade_methods(d): + syms = set() + for f in glob.glob(os.path.join(d, "MeosOps*.java")): + syms |= set(_PUBSTATIC.findall(open(f).read())) + return syms + + +def libmeos_symbols(path): + out = subprocess.run(["nm", "-D", path], capture_output=True, text=True).stdout + return {line.split()[-1] for line in out.splitlines() if line.strip()} + + +def public_surface(inc): + fam, allpub = {}, set() + for h in PUBLIC_HEADERS: + names = set(_DECL.findall(open(os.path.join(inc, h)).read())) + for n in names: + allpub.add(n); fam.setdefault(n, h) + return allpub, fam + + +def sql_csymbols(root): + create = re.compile(r'CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([A-Za-z0-9_]+)\s*\(', re.I) + csym = re.compile(r"AS\s+'[^']*'\s*,\s*'([A-Za-z0-9_]+)'", re.I) + langsql = re.compile(r"LANGUAGE\s+'?(?:sql|plpgsql)'?", re.I) + addressable, oos, sqlc = set(), 0, 0 + for path in glob.glob(os.path.join(root, "**", "*.in.sql"), recursive=True): + section = os.path.relpath(path, root).replace(os.sep, "/") + txt = open(path, encoding="utf-8", errors="replace").read() + for m in create.finditer(txt): + name = m.group(1); tail = txt[m.end():m.end() + 1200].split(';')[0] + cm = csym.search(tail); sym = cm.group(1) if cm else None + key = (sym or name).lower() + if section in OOS_SECTIONS or key in OOS_NAMES or key.endswith(OOS_SUFFIXES): + oos += 1; continue + if sym is None: + sqlc += 1; continue + addressable.add(sym.lower()) + return addressable, oos, sqlc + + +def main(): + ap = argparse.ArgumentParser() + here = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + ap.add_argument("--meos-include", default="/home/esteban/src/MobilityDB/meos/include") + ap.add_argument("--jar", default=os.path.join(here, "jar", "JMEOS.jar")) + ap.add_argument("--facade", default=os.path.join(here, "src/main/java/org/mobilitydb/kafka/meos")) + ap.add_argument("--mdb-sql", default="/home/esteban/src/MobilityDB/mobilitydb/sql") + ap.add_argument("--out", default=os.path.join(here, "docs", "parity-status.md")) + ap.add_argument("--libmeos", default=None, + help="path to a built libmeos.so; cross-checks that every facade method " + "resolves to an exported symbol (runtime resolution check)") + a = ap.parse_args() + + jm = jmeos_symbols(a.jar) + fa_all = facade_methods(a.facade) + fa = fa_all & jm + pub, fam = public_surface(a.meos_include) + bindable = pub & jm + covered = bindable & fa + missing = sorted(bindable - fa) + + bc, cc = collections.Counter(), collections.Counter() + for n in bindable: + bc[fam[n]] += 1 + if n in covered: + cc[fam[n]] += 1 + + addr, oos, sqlc = sql_csymbols(a.mdb_sql) + sql_cov = len(addr & fa); sql_bindable = len(addr & jm) + + pct = lambda c, t: (100.0 * c / t) if t else 0.0 + L = [] + L.append("# MobilityKafka parity status — MEOS surface audit\n") + L.append(f"Generated {date.today().isoformat()} by `tools/parity/parity_audit.py`.\n") + L.append("The MobilityKafka MEOS facade (`org.mobilitydb.kafka.meos.MeosOps*`) exposes " + "MEOS C functions to Flink through JMEOS. This audit measures, per type family, " + "the share of the **MEOS public C API** that the facade exposes and that JMEOS binds.\n") + L.append(f"**Headline.** The facade exposes **{len(covered)} of {len(bindable)} " + f"public MEOS functions ({pct(len(covered), len(bindable)):.1f}%)**. " + f"The MEOS public surface (`meos/include/meos*.h`, excluding internal headers) is " + f"{len(pub)} functions; JMEOS binds {len(bindable)} of them. " + f"{len(missing)} bindable functions are not exposed (listed in §3).\n") + L.append("Coverage is **static**: a function counts as covered when the facade declares a " + "method of the same name and arity that delegates to a JMEOS export.\n") + L.append("Per-family runtime behaviour is asserted by " + "`src/test/java/org/mobilitydb/kafka/meos/MeosFacadeSmokeTest.java`, which constructs " + "and reads back a value in the core, geo, cbuffer, npoint and pose families through the " + "facade against libmeos. The cbuffer, npoint and pose families require a libmeos built " + "with the extended modules (`-DCBUFFER=ON -DNPOINT=ON -DPOSE=ON -DRGEO=ON`); the stock " + "library carries the core and geo surfaces only.\n") + L.append("## 1. Reference surface and method\n") + L.append("- **Denominator**: distinct function names declared `extern` in the MEOS public " + "headers `meos.h`, `meos_geo.h`, `meos_cbuffer.h`, `meos_npoint.h`, `meos_pose.h`, " + "`meos_rgeo.h`. Internal headers (`meos_internal*.h`) are excluded.\n") + L.append("- **Numerator**: `public static` methods on the generated `MeosOps*` facade whose " + "name is also a `functions.GeneratedFunctions` export in the bundled JMEOS jar.\n") + L.append(f"- **JMEOS jar**: {os.path.relpath(a.jar, here)} exports {len(jm)} static methods.\n") + L.append("## 2. Per-family coverage of the public MEOS surface\n") + L.append("| Family (header) | Public ∩ JMEOS | Exposed | Missing | Coverage |") + L.append("|---|---:|---:|---:|---:|") + for h in PUBLIC_HEADERS: + b, c = bc[h], cc[h] + L.append(f"| {FAMILY[h]} (`{h}`) | {b} | {c} | {b - c} | {pct(c, b):.1f}% |") + L.append(f"| **total** | **{len(bindable)}** | **{len(covered)}** | " + f"**{len(bindable) - len(covered)}** | **{pct(len(covered), len(bindable)):.1f}%** |\n") + L.append("## 3. Bindable MEOS functions not exposed by the facade\n") + L.append(f"{len(missing)} functions are present in the public MEOS headers and bound by " + "JMEOS but not generated into the facade:\n") + for h in PUBLIC_HEADERS: + ms = [n for n in missing if fam[n] == h] + if ms: + L.append(f"- **`{h}`** ({len(ms)}): " + ", ".join(f"`{n}`" for n in ms)) + L.append("") + L.append("## 4. MobilityDB SQL-surface cross-check\n") + L.append("The facade is also matched against the underlying MEOS C symbol of each addressable " + "`CREATE FUNCTION` in `mobilitydb/sql/**/*.in.sql` (PG-only sections and helper symbols " + f"bucketed out; {oos} out-of-scope, {sqlc} SQL/plpgsql-composed functions with no single " + "C symbol). Functions the SQL layer implements through the internal MEOS headers " + "(`meos_internal*.h`) are exposed via `MeosOpsSqlSurface`.\n") + L.append(f"- Addressable distinct C symbols: **{len(addr)}**; bound by JMEOS: **{sql_bindable}**; " + f"exposed by the facade: **{sql_cov}** " + f"({pct(sql_cov, sql_bindable):.1f}% of the JMEOS-bindable SQL surface).\n") + L.append(f"- The remaining **{len(addr) - sql_bindable}** addressable C symbols are not exported " + "by JMEOS under the name the SQL layer's extension wrapper uses; the wrapper names " + "differ from the MEOS function names they call.\n") + + if a.libmeos: + libsyms = libmeos_symbols(a.libmeos) + resolved = fa_all & libsyms + unresolved = sorted(fa_all - libsyms) + L.append("## 5. Runtime symbol resolution\n") + L.append("Every facade method delegates to a libmeos symbol of the same name. Against a " + "MEOS shared library built with the extended modules (`-DCBUFFER=ON -DNPOINT=ON " + "-DPOSE=ON -DRGEO=ON`), " + f"**{len(resolved)} of {len(fa_all)}** facade methods resolve to an exported " + "symbol.\n") + if unresolved: + hdr_only = sorted(n for n in unresolved if n in pub) + jmeos_only = sorted(n for n in unresolved if n not in pub) + L.append(f"The remaining {len(unresolved)} are present in the JMEOS jar but not " + "exported by the MEOS shared library (a JMEOS-jar / library version skew):\n") + if hdr_only: + L.append(f"- declared in the public headers, not exported by this build " + f"({len(hdr_only)}): " + ", ".join(f"`{n}`" for n in hdr_only)) + if jmeos_only: + L.append(f"- not declared in the current public headers, JMEOS jar ahead of the " + f"library ({len(jmeos_only)}): " + ", ".join(f"`{n}`" for n in jmeos_only)) + L.append("") + else: + L.append("All facade methods resolve.\n") + print(f"libmeos resolution: {len(resolved)}/{len(fa_all)} " + f"({len(unresolved)} unresolved)") + + md = "\n".join(L) + "\n" + os.makedirs(os.path.dirname(a.out), exist_ok=True) + open(a.out, "w").write(md) + + print(f"public MEOS surface: {len(pub)}") + print(f" bound by JMEOS: {len(bindable)}") + print(f" exposed by facade: {len(covered)} ({pct(len(covered), len(bindable)):.1f}%)") + print(f" missing (bindable): {len(missing)}") + print(f"SQL addressable C-symbols: {len(addr)} (bindable {sql_bindable}, exposed {sql_cov})") + print(f"wrote {a.out}") + + +if __name__ == "__main__": + main()